rubocop 1.92.1 → 1.92.2

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

@@ -146,8 +146,8 @@ module RuboCop
             comment = directive_comment(line_range)
             next if skip_directive?(comment)
 
-            next_range = line_ranges[line_range_index + 1]
-            redundant = find_redundant_directive(cop, comment, line_range, next_range)
+            following_ranges = line_ranges[(line_range_index + 1)..]
+            redundant = find_redundant_directive(cop, comment, line_range, following_ranges)
             yield comment, redundant if redundant
           end
         end
@@ -191,14 +191,33 @@ module RuboCop
           directive.push? || directive.pop? || directive.next?
         end
 
-        def find_redundant_directive(cop, comment, line_range, next_range)
-          if all_disabled?(comment)
-            find_redundant_all(line_range, next_range)
-          elsif department_disabled?(cop, comment)
-            find_redundant_department(cop, line_range)
+        def find_redundant_directive(cop, comment, line_range, following_ranges)
+          return find_redundant_all(line_range, following_ranges.first) if all_disabled?(comment)
+
+          range = line_range_through_repeated_disables(cop, line_range, following_ranges)
+          if department_disabled?(cop, comment)
+            find_redundant_department(cop, range)
           else
-            find_redundant_cop(cop, line_range)
+            find_redundant_cop(cop, range)
+          end
+        end
+
+        def line_range_through_repeated_disables(cop, line_range, following_ranges)
+          last_range = line_range
+          following_ranges.each do |range|
+            break unless followed_ranges?(last_range, range) && repeated_disable?(cop, range)
+
+            last_range = range
           end
+
+          line_range.begin..last_range.end
+        end
+
+        def repeated_disable?(cop, range)
+          comment = directive_comment(range)
+          return false if comment.nil? || skip_directive?(comment)
+
+          !all_disabled?(comment) && !department_disabled?(cop, comment)
         end
 
         # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

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

@@ -118,10 +118,7 @@ module RuboCop
         def redundant_splat_expansion(node)
           literal_expansion(node) do |expanded_item|
             if expanded_item.send_type?
-              return if array_new_inside_array_literal?(expanded_item)
-
-              grandparent = node.parent.parent
-              return if grandparent && !ASSIGNMENT_TYPES.include?(grandparent.type)
+              return unless redundant_array_new_splat?(node, expanded_item)
             # An empty array/percent literal (`*[]`, `*%w()`, ...) expands to nothing, so
             # removing the splat would produce invalid or semantically different code.
             elsif expanded_item.array_type? && expanded_item.children.empty?
@@ -132,6 +129,16 @@ module RuboCop
           end
         end
 
+        # A splatted `Array.new` passed as a method argument provides the arguments,
+        # so the splat is only redundant directly inside an array.
+        def redundant_array_new_splat?(node, array_new_node)
+          return false unless node.parent.array_type?
+          return false if array_new_inside_array_literal?(array_new_node)
+
+          grandparent = node.parent.parent
+          !grandparent || ASSIGNMENT_TYPES.include?(grandparent.type)
+        end
+
         def array_new_inside_array_literal?(array_new_node)
           return false unless array_new?(array_new_node)
 

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

@@ -66,7 +66,7 @@ module RuboCop
       # the line at which the parent node ends.
       # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def find_end_line(node)
-        if node.if_type?
+        if node.if_type? && !node.modifier_form?
           if node.else?
             node.loc.else.line
           elsif node.ternary?

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

@@ -55,10 +55,17 @@ module RuboCop
       # Common functionality for checking alignment of hash values.
       module ValueAlignment
         def checkable_layout?(node)
-          !node.pairs_on_same_line? && !node.mixed_delimiters? && alignable_values?(node)
+          !node.pairs_on_same_line? && !node.mixed_delimiters? && alignable_values?(node) &&
+            !pair_after_kwsplat_on_same_line?(node)
         end
 
+        # With several enforced styles, deltas are computed even for a hash this style
+        # can't check. A pair that doesn't begin its line can't be moved without
+        # deleting whatever precedes it, so it's left alone.
         def deltas(first_pair, current_pair)
+          return {} unless current_pair.equal?(first_pair) ||
+                           Util.begins_its_line?(current_pair.source_range)
+
           key_delta = key_delta(first_pair, current_pair)
           shift = separator_shift(current_pair, key_delta)
           separator_delta = separator_delta(first_pair, current_pair, shift)
@@ -79,6 +86,15 @@ module RuboCop
           pair.value && pair.key.last_line != pair.value.first_line
         end
 
+        def pair_after_kwsplat_on_same_line?(node)
+          first_pair = node.pairs.first
+
+          node.children.each_cons(2).any? do |previous, current|
+            current.pair_type? && !current.equal?(first_pair) &&
+              previous.last_line == current.first_line
+          end
+        end
+
         def separator_shift(current_pair, key_delta)
           current_pair.key.multiline? ? 0 : key_delta
         end

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

@@ -7,6 +7,8 @@ module RuboCop
       include LineLengthHelp
       include AllowedPattern
 
+      SPACE_INSIDE_PARENS_STYLES = %w[space compact].freeze
+
       private
 
       def single_line_as_modifier?(node)
@@ -42,7 +44,10 @@ module RuboCop
       def modifier_fits_on_single_line?(node)
         return true unless max_line_length
 
-        line_length(line_in_modifier_form(node)) <= max_line_length
+        length = line_length(line_in_modifier_form(node))
+        length += 2 if parenthesize?(node) && space_inside_parens?
+
+        length <= max_line_length
       end
 
       def line_in_modifier_form(node)
@@ -52,6 +57,14 @@ module RuboCop
         "#{code_before}#{to_modifier_form(node)}#{code_after(node)}"
       end
 
+      def space_inside_parens?
+        return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+        style = config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle']
+
+        SPACE_INSIDE_PARENS_STYLES.include?(style)
+      end
+
       # Whether an existing line is acceptable to `Layout/LineLength`,
       # exemptions (the cop disabled at that line, an allowed pattern, an
       # allowed cop directive, an allowed URI) included. Only for judging

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

@@ -163,7 +163,7 @@ module RuboCop
 
       def put_comma(items, kind)
         last_item = items.last
-        return if last_item.block_pass_type?
+        return if last_item.type?(:block_pass, :forwarded_args)
 
         range = autocorrect_range(last_item)
         msg = format(MSG, command: 'Put a', unit: format(kind, article: 'a multiline'))

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

@@ -72,13 +72,7 @@ module RuboCop
 
           message = message(node)
           add_offense(node.loc.operator, message: message) do |corrector|
-            node.each_child_node do |expr|
-              if expr.call_type?
-                correct_send(expr, corrector)
-              elsif expr.type?(:return, :next, :break, :yield) || expr.assignment?
-                correct_other(expr, corrector)
-              end
-            end
+            node.each_child_node { |expr| correct_operand(expr, corrector) }
 
             corrector.replace(node.loc.operator, node.alternate_operator)
 
@@ -86,6 +80,22 @@ module RuboCop
           end
         end
 
+        def correct_operand(expr, corrector)
+          expr = expr.send_node if expr.any_block_type?
+
+          if expr.type?(:call, :super)
+            correct_send(expr, corrector)
+          elsif wrap_in_parentheses?(expr)
+            correct_other(expr, corrector)
+          end
+        end
+
+        # These bind looser than `&&` and `||`, or can't be their operands at all.
+        def wrap_in_parentheses?(node)
+          node.type?(:return, :next, :break, :yield, :any_match_pattern, :range, :defined?) ||
+            node.assignment? || (node.if_type? && node.ternary?)
+        end
+
         def on_conditionals(node)
           node.condition.each_node(*AST::Node::OPERATOR_KEYWORDS) do |operator|
             process_logical_operator(operator)
@@ -101,6 +111,7 @@ module RuboCop
           return correct_setter(node, corrector) if node.setter_method?
           return correct_other(node, corrector) if node.comparison_method?
 
+          correct_block_receiver(node, corrector)
           return unless correctable_send?(node)
 
           whitespace_before_arg_range = whitespace_before_arg(node)
@@ -120,7 +131,8 @@ module RuboCop
         # however, 'not x' also parses as (send x :!)
         def correct_not(node, receiver, corrector)
           if node.prefix_bang?
-            return unless receiver.call_type?
+            receiver = receiver.send_node if receiver.any_block_type?
+            return unless receiver.type?(:call, :super)
 
             correct_send(receiver, corrector)
           elsif node.prefix_not?
@@ -145,12 +157,23 @@ module RuboCop
           end
         end
 
+        # A method chained onto a `do` block, as in `bar baz do ... end.qux`,
+        # still needs parentheses around the arguments of the call that takes the block.
+        def correct_block_receiver(node, corrector)
+          receiver = node.receiver
+          receiver = receiver.receiver while receiver&.call_type?
+          correct_operand(receiver, corrector) if receiver&.any_block_type?
+        end
+
         def correctable_send?(node)
-          !node.parenthesized? && node.arguments? && !node.method?(:[])
+          # Operator syntax such as `a + b` or `a[b]` already binds tighter than `&&` and `||`.
+          return false if node.operator_method? && !node.loc.dot
+
+          !node.parenthesized? && node.arguments?
         end
 
         def whitespace_before_arg(node)
-          begin_paren = node.loc.selector.end_pos
+          begin_paren = node.selector.end_pos
           end_paren = begin_paren
           # Increment position of parenthesis, unless message is a predicate
           # method followed by a non-whitespace char (e.g. is_a?String).

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

@@ -7,7 +7,7 @@ module RuboCop
       # The `===` operator has different behavior depending on the
       # receiver and its use outside of `case`/`when` is confusing.
       # Prefer more explicit alternatives like `is_a?`, `include?`,
-      # or `match?`.
+      # `cover?`, or `match?`.
       #
       # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is a constant.
@@ -22,9 +22,11 @@ module RuboCop
       # @example
       #   # bad
       #   (1..100) === 7
+      #   ('a'..'z') === char
       #
       #   # good
       #   (1..100).include?(7)
+      #   ('a'..'z').cover?(char)
       #
       # @example AllowOnConstant: false (default)
       #   # bad
@@ -90,9 +92,18 @@ module RuboCop
         end
 
         def begin_replacement(lhs, rhs)
-          return unless lhs.children.first&.range_type?
+          range = lhs.children.first
+          return unless range&.range_type?
 
-          "#{lhs.source}.include?(#{rhs.source})"
+          method = cover_semantics?(range) ? 'cover?' : 'include?'
+
+          "#{lhs.source}.#{method}(#{rhs.source})"
+        end
+
+        # `Range#===` behaves like `Range#cover?` since Ruby 2.7 (since Ruby 2.6 for ranges
+        # that aren't string ranges), and `Range#include?` only matches that for numeric ranges.
+        def cover_semantics?(range)
+          target_ruby_version >= 2.7 && !range.children.compact.all?(&:numeric_type?)
         end
 
         def const_replacement(lhs, rhs)

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

@@ -65,10 +65,11 @@ module RuboCop
         NESTED_MSG = 'Use nested module/class definitions instead of compact style.'
         COMPACT_MSG = 'Use compact module/class definition instead of nested style.'
 
-        # `Style/StructInheritance` turns a class definition into a constant assignment in
-        # the same pass, which the compacted `class` keyword would then precede.
+        # `Style/StructInheritance` and `Style/DataInheritance` turn a class definition into
+        # a constant assignment in the same pass, which the compacted `class` keyword would
+        # then precede.
         def self.autocorrect_incompatible_with
-          [Style::StructInheritance]
+          [Style::DataInheritance, Style::StructInheritance]
         end
 
         def on_class(node)

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

@@ -151,8 +151,17 @@ module RuboCop
         # which an endless definition cannot hold.
         # `Style/RaiseArgs` would drop the parentheses of a `raise` that becomes
         # the body in the same pass, which a method passed as an argument needs.
+        # `Style/IfUnlessModifier` and `Style/WhileUntilModifier` would turn the body into
+        # a modifier form, which then applies to the whole endless definition.
         def self.autocorrect_incompatible_with
-          [Style::GuardClause, Style::MethodCallWithArgsParentheses, Style::MethodDefParentheses, Style::RaiseArgs]
+          [
+            Style::GuardClause,
+            Style::IfUnlessModifier,
+            Style::MethodCallWithArgsParentheses,
+            Style::MethodDefParentheses,
+            Style::RaiseArgs,
+            Style::WhileUntilModifier
+          ]
         end
 
         def on_def(node)
@@ -189,9 +198,7 @@ module RuboCop
             add_offense(node, message: MSG_MULTI_LINE) do |corrector|
               correct_to_multiline(corrector, node)
             end
-          elsif !node.endless? && can_be_made_endless?(node) && single_line_when_made_endless?(node)
-            return if too_long_when_made_endless?(node)
-
+          elsif convertible_to_endless?(node) && single_line_when_made_endless?(node)
             add_offense(node, message: MSG_REQUIRE_SINGLE) do |corrector|
               correct_to_endless(corrector, node)
             end
@@ -199,14 +206,18 @@ module RuboCop
         end
 
         def handle_require_always_style(node)
-          return if node.endless? || !can_be_made_endless?(node)
-          return if too_long_when_made_endless?(node)
+          return unless convertible_to_endless?(node)
 
           add_offense(node, message: MSG_REQUIRE_ALWAYS) do |corrector|
             correct_to_endless(corrector, node)
           end
         end
 
+        def convertible_to_endless?(node)
+          !node.endless? && can_be_made_endless?(node) &&
+            !too_long_when_made_endless?(node) && !ambiguous_when_made_endless?(node)
+        end
+
         def handle_disallow_style(node)
           return unless node.endless?
 
@@ -297,6 +308,23 @@ module RuboCop
           !endless_replacement(node).include?("\n")
         end
 
+        def ambiguous_when_made_endless?(node)
+          (operation = ambiguous_operation(node)) && ambiguous_enclosing_operation?(operation)
+        end
+
+        # @!method ambiguous_operation(node)
+        def_node_matcher :ambiguous_operation, <<~PATTERN
+          ^${
+            (if _ <any_def _>)
+            ({and or} any_def _)
+            ({while until} _ any_def)
+          }
+        PATTERN
+
+        def ambiguous_enclosing_operation?(operation)
+          operation.operator_keyword? || operation.modifier_form?
+        end
+
         def too_long_when_made_endless?(node)
           return false unless config.cop_enabled?('Layout/LineLength')
 

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

@@ -146,11 +146,26 @@ module RuboCop
         end
 
         def comment_before_to_f?(node)
+          return true if comment_around_fdiv_operator?(node)
+
           operands_losing_to_f(node).any? do |operand|
             next false unless to_f_method?(operand)
 
             range = operand.receiver.source_range.end.join(operand.loc.selector.begin)
-            processed_source.contains_comment?(range)
+            comment_in_range?(range)
+          end
+        end
+
+        def comment_around_fdiv_operator?(node)
+          return false unless style == :fdiv
+
+          range = node.receiver.source_range.end.join(node.first_argument.source_range.begin)
+          comment_in_range?(range)
+        end
+
+        def comment_in_range?(range)
+          processed_source.each_comment_in_lines(range.line..range.last_line).any? do |comment|
+            range.contains?(comment.source_range)
           end
         end
 

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

@@ -45,7 +45,7 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::TrailingCommaInArrayLiteral]
+          [Layout::MultilineArrayBraceLayout, Style::TrailingCommaInArrayLiteral]
         end
 
         def on_hash(node)

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

@@ -90,9 +90,19 @@ module RuboCop
         end
 
         def exempt_from_brackets?(node)
+          return true if forwarded_or_splatted?(node.first_argument)
+
           comment_before_dot?(node) || env_fetch_preferred?(node.receiver)
         end
 
+        def forwarded_or_splatted?(argument)
+          if argument.hash_type? && !argument.braces?
+            argument.children.any? { |child| child.type?(:kwsplat, :forwarded_kwrestarg) }
+          else
+            argument.type?(:forwarded_args, :forwarded_restarg, :splat, :block_pass)
+          end
+        end
+
         def comment_before_dot?(node)
           processed_source.contains_comment?(node.receiver.source_range.end.join(node.loc.dot))
         end

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

@@ -243,6 +243,7 @@ module RuboCop
 
         def self.autocorrect_incompatible_with
           [
+            Layout::HeredocArgumentClosingParenthesis,
             Style::NestedParenthesizedCalls,
             Style::RedundantParentheses,
             Style::RescueModifier,

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

@@ -169,12 +169,20 @@ module RuboCop
           location = node.arguments.source_range
 
           add_offense(location, message: MSG_MISSING) do |corrector|
-            add_parentheses(node.arguments, corrector)
+            corrector.replace(range_before_arguments(node), '(')
+            corrector.insert_after(location, ')')
 
             unexpected_style_detected 'require_no_parentheses'
           end
         end
 
+        def range_before_arguments(node)
+          range = node.loc.name.end.join(node.arguments.source_range.begin)
+          last_line_break = range.source.rindex("\n")
+
+          last_line_break ? range.resize(last_line_break) : range
+        end
+
         def unwanted_parentheses(args)
           add_offense(args, message: MSG_PRESENT) do |corrector|
             # offense is registered on args node when parentheses are unwanted

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

@@ -99,7 +99,10 @@ module RuboCop
 
           message = format(MSG, prefer: replacement, current: node.source)
           add_offense(node, message: message) do |corrector|
+            next if inside_corrected_predicate?(node)
+
             corrector.replace(node, replacement)
+            ignore_node(node)
           end
         end
 
@@ -115,6 +118,10 @@ module RuboCop
             BitwisePredicate.support_target_ruby_version?(target_ruby_version)
         end
 
+        def inside_corrected_predicate?(node)
+          node.each_ancestor(:send).any? { |ancestor| ignored_node?(ancestor) }
+        end
+
         def check(node)
           numeric, operator =
             if style == :predicate

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

@@ -84,6 +84,7 @@ module RuboCop
             return if require_parentheses?(node, first_child)
             return if semicolon_separated_expressions?(first_child, rest_children)
             return if modifier_op?(first_child) || first_child.masgn_type?
+            return if command_call_assignment?(first_child)
             return if parens_allowed?(cond)
 
             message = message(cond)
@@ -115,6 +116,23 @@ module RuboCop
           node.basic_conditional? && node.modifier_form?
         end
 
+        def command_call_assignment?(node)
+          return false if !node.assignment? && !setter_method?(node)
+
+          value = node.children.last
+          value = value.body if value.rescue_type?
+
+          command_call_assignment?(value) || command_call?(value)
+        end
+
+        def command_call?(node)
+          node = node.send_node if node.any_block_type?
+          return false if !node.type?(:call, :super, :yield) || !node.arguments?
+          return false if node.parenthesized? || node.operator_method? || node.setter_method?
+
+          !node.method?(:[])
+        end
+
         def message(node)
           kw = node.parent.keyword
           article = kw == 'while' ? 'a' : 'an'

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

@@ -86,14 +86,12 @@ module RuboCop
         end
 
         def correct_quotes(str)
-          correction = if style == :single_quotes
-                         to_string_literal(str)
-                       else
-                         str.gsub("\\'", "'").inspect
-                       end
-
           # The conversion process doubles escaped slashes, so they have to be reverted
-          correction.gsub('\\\\', '\\').gsub('\"', '"')
+          if style == :single_quotes
+            to_string_literal(str).gsub('\\\\', '\\').gsub('\"', '"')
+          else
+            str.gsub("\\'", "'").inspect.gsub('\\\\', '\\')
+          end
         end
 
         def style