rubocop 1.84.2 → 1.88.0

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

@@ -232,9 +232,7 @@ module RuboCop
         end
 
         def semantic_message(node)
-          block_begin = node.loc.begin.source
-
-          if block_begin == '{'
+          if node.braces?
             'Prefer `do...end` over `{...}` for procedural blocks.'
           else
             'Prefer `{...}` over `do...end` for functional blocks.'
@@ -372,36 +370,42 @@ module RuboCop
         end
         # rubocop:enable Metrics/CyclomaticComplexity
 
+        # rubocop:disable Metrics/CyclomaticComplexity -- inlined special_method checks to avoid double evaluation
         def proper_block_style?(node)
           return true if require_do_end?(node)
-          return special_method_proper_block_style?(node) if special_method?(node.method_name)
+
+          method_name = node.method_name
+          return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+          return node.braces? if braces_required_method?(method_name)
 
           case style
           when :line_count_based    then line_count_based_block_style?(node)
           when :semantic            then semantic_block_style?(node)
           when :braces_for_chaining then braces_for_chaining_style?(node)
-          when :always_braces       then braces_style?(node)
+          when :always_braces       then node.braces?
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def require_do_end?(node)
           return false if node.braces? || node.multiline?
-          return false unless (resbody = node.each_descendant(:resbody).first)
 
-          resbody.children.first&.array_type?
-        end
+          body = node.body
+          return false unless body
+          # `ensure` and a block-level `rescue` are illegal inside `{ }`; only a
+          # bare modifier rescue (`expr rescue expr`) can be written with braces.
+          return true if body.ensure_type?
+          return false unless body.rescue_type?
 
-        def special_method?(method_name)
-          allowed_method?(method_name) ||
-            matches_allowed_pattern?(method_name) ||
-            braces_required_method?(method_name)
+          !modifier_rescue?(body)
         end
 
-        def special_method_proper_block_style?(node)
-          method_name = node.method_name
-          return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+        def modifier_rescue?(rescue_node)
+          return false if rescue_node.body.nil? || rescue_node.else_branch
+          return false unless rescue_node.resbody_branches.one?
 
-          node.braces? if braces_required_method?(method_name)
+          resbody = rescue_node.resbody_branches.first
+          resbody.exceptions.empty? && resbody.exception_variable.nil?
         end
 
         def braces_required_method?(method_name)
@@ -421,24 +425,18 @@ module RuboCop
 
           if node.braces?
             functional_method?(method_name) || functional_block?(node) ||
-              (procedural_oneliners_may_have_braces? && !node.multiline?)
+              (procedural_oneliners_may_have_braces? && node.single_line?)
           else
             procedural_method?(method_name) || !return_value_used?(node)
           end
         end
 
         def braces_for_chaining_style?(node)
-          block_begin = node.loc.begin.source
-
-          block_begin == if node.multiline?
-                           (node.chained? ? '{' : 'do')
-                         else
-                           '{'
-                         end
-        end
-
-        def braces_style?(node)
-          node.loc.begin.source == '{'
+          if node.multiline?
+            node.chained? ? node.braces? : !node.braces?
+          else
+            node.braces?
+          end
         end
 
         def correction_would_break_code?(node)
@@ -448,7 +446,11 @@ module RuboCop
         end
 
         def functional_method?(method_name)
-          cop_config['FunctionalMethods'].map(&:to_sym).include?(method_name)
+          functional_methods.include?(method_name)
+        end
+
+        def functional_methods
+          @functional_methods ||= cop_config['FunctionalMethods'].to_set(&:to_sym).freeze
         end
 
         def functional_block?(node)
@@ -460,7 +462,11 @@ module RuboCop
         end
 
         def procedural_method?(method_name)
-          cop_config['ProceduralMethods'].map(&:to_sym).include?(method_name)
+          procedural_methods.include?(method_name)
+        end
+
+        def procedural_methods
+          @procedural_methods ||= cop_config['ProceduralMethods'].to_set(&:to_sym).freeze
         end
 
         def return_value_used?(node)
@@ -489,7 +495,7 @@ module RuboCop
         def begin_required?(block_node)
           # If the block contains `rescue` or `ensure`, it needs to be wrapped in
           # `begin`...`end` when changing `do-end` to `{}`.
-          block_node.each_child_node(:rescue, :ensure).any? && !block_node.single_line?
+          block_node.each_child_node(:rescue, :ensure).any? && block_node.multiline?
         end
 
         def single_argument_operator_method?(node)

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

@@ -4,6 +4,10 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of the case equality operator (`===`).
+      # 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?`.
       #
       # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is a constant.
@@ -92,13 +96,25 @@ module RuboCop
         end
 
         def const_replacement(lhs, rhs)
-          "#{rhs.source}.is_a?(#{lhs.source})"
+          "#{parenthesize_if_needed(rhs)}.is_a?(#{lhs.source})"
         end
 
         def send_replacement(lhs, rhs)
           return unless self_class?(lhs)
 
-          "#{rhs.source}.is_a?(#{lhs.source})"
+          "#{parenthesize_if_needed(rhs)}.is_a?(#{lhs.source})"
+        end
+
+        # `Array === a + b` must become `(a + b).is_a?(Array)`, not
+        # `a + b.is_a?(Array)` (which parses as `a + (b.is_a?(Array))`).
+        def parenthesize_if_needed(node)
+          requires_parentheses?(node) ? "(#{node.source})" : node.source
+        end
+
+        def requires_parentheses?(node)
+          return true if node.type?(:and, :or, :if, :range) || node.assignment?
+
+          node.send_type? && (node.operator_method? || node.unary_operation?)
         end
       end
     end

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

@@ -8,8 +8,8 @@ module RuboCop
       # essentially one-character strings, so this syntax
       # is mostly redundant at this point.
       #
-      # ? character literal can be used to express meta and control character.
-      # That's a good use case of ? literal so it doesn't count it as an offense.
+      # A `?` character literal can be used to express meta and control characters.
+      # That's a good use case of a `?` literal so it doesn't count as an offense.
       #
       # @example
       #   # bad

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

@@ -28,16 +28,24 @@ module RuboCop
       #   manual oversight.
       #
       # @example EnforcedStyle: nested (default)
+      #   # bad
+      #   class Foo::Bar
+      #   end
+      #
       #   # good
-      #   # have each child on its own line
       #   class Foo
       #     class Bar
       #     end
       #   end
       #
       # @example EnforcedStyle: compact
+      #   # bad
+      #   class Foo
+      #     class Bar
+      #     end
+      #   end
+      #
       #   # good
-      #   # combine definitions as much as possible
       #   class Foo::Bar
       #   end
       #
@@ -173,6 +181,7 @@ module RuboCop
 
         def check_style(node, body, style)
           return if node.identifier.namespace&.cbase_type?
+          return unless const_namespace?(node.identifier.namespace)
 
           if style == :nested
             check_nested_style(node)
@@ -181,6 +190,13 @@ module RuboCop
           end
         end
 
+        def const_namespace?(node)
+          return true if node.nil? || node.cbase_type?
+          return false unless node.const_type?
+
+          const_namespace?(node.namespace)
+        end
+
         def check_nested_style(node)
           return unless compact_node_name?(node)
           return if node.parent&.type?(:class, :module)

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

@@ -90,25 +90,33 @@ module RuboCop
         private
 
         def class_name(class_node, node)
-          if class_name_method?(node.children.first.method_name)
-            if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
-              return receiver.source
-            end
+          unless class_name_method?(node.children.first.method_name)
+            # `var.class == 'Foo'` compares a `Class` to a `String` (always false) and
+            # has no valid `instance_of?` rewrite, so don't suggest one.
+            return if class_node.str_type?
 
-            if class_node.str_type?
-              value = trim_string_quotes(class_node)
-              value.prepend('::') if require_cbase?(class_node)
-              return value
-            elsif unable_to_determine_type?(class_node)
-              # When a variable or return value of a method is used, it returns nil
-              # because the type is not known and cannot be suggested.
-              return
-            end
+            return class_node.source
+          end
+
+          if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
+            return receiver.source
           end
 
+          return string_class_name(class_node) if class_node.str_type?
+          # When a variable or return value of a method is used, the type is not known
+          # and cannot be suggested.
+          return if unable_to_determine_type?(class_node)
+
           class_node.source
         end
 
+        def string_class_name(class_node)
+          value = trim_string_quotes(class_node)
+          # Avoid `::::Foo` when the name is already fully qualified.
+          value.prepend('::') if require_cbase?(class_node) && !value.start_with?('::')
+          value
+        end
+
         def class_name_method?(method_name)
           CLASS_NAME_METHODS.include?(method_name)
         end

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

@@ -140,15 +140,21 @@ module RuboCop
 
         def extract_def_from_sclass(def_node, sclass_node)
           range = source_range_with_comment(def_node)
-          source = range.source.sub!(
-            "def #{def_node.method_name}",
-            "def self.#{def_node.method_name}"
-          )
-
+          source = prefix_def_with_self(range, def_node)
           source = source.gsub(/^ {#{indentation_diff(def_node, sclass_node)}}/, '')
           [range, source.chomp]
         end
 
+        # Splice in `self.` at the actual `def` keyword rather than substituting the
+        # first textual `def <name>`, which may appear inside a preceding comment.
+        def prefix_def_with_self(range, def_node)
+          keyword_offset = def_node.loc.keyword.begin_pos - range.begin_pos
+          name_end_offset = def_node.loc.name.end_pos - range.begin_pos
+          source = range.source.dup
+          source[keyword_offset...name_end_offset] = "def self.#{def_node.method_name}"
+          source
+        end
+
         def indentation_diff(node1, node2)
           node1.loc.column - node2.loc.column
         end

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

@@ -64,22 +64,34 @@ module RuboCop
         # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
-            (call
-              !nil? {:reject :reject!})
+            (call !nil? {:reject :reject!})
             $(args ...)
-            (call
-              $(lvar _) :nil?))
+            (call $(lvar _) :nil?))
+        PATTERN
+
+        # @!method reject_method_for_numblock_or_itblock?(node)
+        def_node_matcher :reject_method_for_numblock_or_itblock?, <<~PATTERN
+          {
+            (numblock (call !nil? {:reject :reject!}) _ (call (lvar :_1) :nil?))
+            (itblock (call !nil? {:reject :reject!}) _ (call (lvar :it) :nil?))
+          }
         PATTERN
 
         # @!method select_method?(node)
         def_node_matcher :select_method?, <<~PATTERN
           (block
-            (call
-              !nil? {:select :select! :filter :filter!})
+            (call !nil? {:select :select! :filter :filter!})
             $(args ...)
             (call
-              (call
-                $(lvar _) :nil?) :!))
+              (call $(lvar _) :nil?) :!))
+        PATTERN
+
+        # @!method select_method_for_numblock_or_itblock?(node)
+        def_node_matcher :select_method_for_numblock_or_itblock?, <<~PATTERN
+          {
+            (numblock (call !nil? {:select :select! :filter :filter!}) _ (call (call (lvar :_1) :nil?) :!))
+            (itblock (call !nil? {:select :select! :filter :filter!}) _ (call (call (lvar :it) :nil?) :!))
+          }
         PATTERN
 
         # @!method grep_v_with_nil?(node)
@@ -102,26 +114,34 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def offense_range(node)
           if reject_method_with_block_pass?(node) || grep_v_with_nil?(node)
             range(node, node)
           else
             block_node = node.parent
 
-            return unless block_node&.block_type?
-            unless (args, receiver = reject_method?(block_node) || select_method?(block_node))
-              return
-            end
-            return unless args.last.source == receiver.source
+            return unless block_node&.any_block_type?
+            return unless match_block_method?(block_node)
 
             range(node, block_node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def match_block_method?(block_node)
+          if block_node.block_type?
+            result = reject_method?(block_node) || select_method?(block_node)
+            return false unless result
+
+            args, receiver = result
+            args.last.source == receiver.source
+          else
+            reject_method_for_numblock_or_itblock?(block_node) ||
+              select_method_for_numblock_or_itblock?(block_node)
+          end
+        end
 
         def to_enum_method?(node)
-          return false unless node.receiver.send_type?
+          return false unless node.receiver.call_type?
 
           TO_ENUM_METHODS.include?(node.receiver.method_name)
         end

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

@@ -4,7 +4,9 @@ module RuboCop
   module Cop
     module Style
       # Checks for methods invoked via the `::` operator instead
-      # of the `.` operator (like `FileUtils::rmdir` instead of `FileUtils.rmdir`).
+      # of the `.` operator (like `FileUtils::rmdir` instead of
+      # `FileUtils.rmdir`). The `::` operator is conventionally used to
+      # reference constants, so using it for method calls can be misleading.
       #
       # @example
       #   # bad
@@ -22,10 +24,9 @@ module RuboCop
 
         MSG = 'Do not use `::` for method calls.'
 
-        # @!method java_type_node?(node)
-        def_node_matcher :java_type_node?, <<~PATTERN
-          (send
-            (const nil? :Java) _)
+        # @!method java_root?(node)
+        def_node_matcher :java_root?, <<~PATTERN
+          (const nil? :Java)
         PATTERN
 
         def self.autocorrect_incompatible_with
@@ -35,11 +36,19 @@ module RuboCop
         def on_send(node)
           return unless node.receiver && node.double_colon?
           return if node.camel_case_method?
-          # ignore Java interop code like Java::int
-          return if java_type_node?(node)
+          # ignore Java interop code like `Java::int` or `Java::com::method`
+          return if java_interop?(node)
 
           add_offense(node.loc.dot) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
+
+        private
+
+        def java_interop?(node)
+          receiver = node.receiver
+          receiver = receiver.receiver while receiver.respond_to?(:receiver) && receiver.receiver
+          java_root?(receiver)
+        end
       end
     end
   end

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

@@ -85,8 +85,13 @@ module RuboCop
         def on_for(node)
           return unless node.parent&.begin_type?
           return unless same_collection_looping_for?(node, node.left_sibling)
+          return unless node.body && node.left_sibling.body
 
           add_offense(node) do |corrector|
+            # Combining loops with different iteration variables would leave the second
+            # body referencing an undefined variable, so only autocorrect when they match.
+            next unless node.variable == node.left_sibling.variable
+
             combine_with_left_sibling(corrector, node)
           end
         end

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

@@ -90,7 +90,7 @@ module RuboCop
             max = if_body.source
           end
 
-          prefer = "#{else_body_source}.clamp(#{min}, #{max})"
+          prefer = "#{parenthesize_if_needed(else_body)}.clamp(#{min}, #{max})"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
             autocorrect(corrector, node, prefer)
@@ -119,6 +119,17 @@ module RuboCop
 
           (lhs.source == else_body && op == :<) || (rhs.source == else_body && op == :>)
         end
+
+        # `a + b` must become `(a + b).clamp(low, high)`, not `a + b.clamp(low, high)`
+        # (which parses as `a + (b.clamp(low, high))`).
+        def parenthesize_if_needed(node)
+          if node.type?(:and, :or, :if, :range) || node.assignment? ||
+             (node.send_type? && (node.operator_method? || node.unary_operation?))
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
       end
     end
   end

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

@@ -52,7 +52,13 @@ module RuboCop
 
           add_offense(offense, message: message) do |corrector|
             if use_percent_literal
+              next unless prefer
+
               corrector.replace(offense, prefer)
+            elsif node.arguments.any? { |argument| argument.children.empty? }
+              # In-place bracket removal would leave dangling commas (e.g.
+              # `concat([], [b])` -> `push(, b)`), so rebuild the call instead.
+              corrector.replace(offense, preferred_method(node))
             else
               corrector.replace(node.loc.selector, 'push')
               node.arguments.each do |argument|
@@ -73,7 +79,7 @@ module RuboCop
 
         def preferred_method(node)
           new_arguments =
-            node.arguments.map do |arg|
+            node.arguments.flat_map do |arg|
               if arg.percent_literal?
                 arg.children.map { |child| child.value.inspect }
               else

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

@@ -99,10 +99,6 @@ module RuboCop
           end
         end
 
-        def setter_method?(method_name)
-          method_name.to_s.end_with?(EQUAL) && !%i[!= == === >= <=].include?(method_name)
-        end
-
         def assignment_rhs_exist?(node)
           parent = node.parent
           return true unless parent
@@ -287,7 +283,10 @@ module RuboCop
 
           _condition, *branches, else_branch = *assignment
 
-          return unless else_branch
+          # Use the node accessor rather than the raw destructured branch: for
+          # `x = unless cond; body; end` (no `else`) the parser puts `body` in the
+          # else slot, but `else_branch` correctly reports there is no `else` clause.
+          return unless assignment.else_branch
           return if allowed_single_line?([*branches, else_branch])
 
           add_offense(node, message: ASSIGN_TO_CONDITION_MSG) do |corrector|
@@ -661,6 +660,8 @@ module RuboCop
             remove_whitespace_in_branches(corrector, branch, condition, column)
 
             parent_keyword = branch.parent.loc.keyword
+            return if same_line?(parent_keyword, condition)
+
             corrector.remove_preceding(parent_keyword, parent_keyword.column - column)
           end
         end

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

@@ -89,7 +89,10 @@ module RuboCop
 
             arguments = arguments.first.children.first.to_a if arguments.first&.splat_type?
             constant_values = arguments.map do |argument|
-              argument.value.to_sym if argument.respond_to?(:value)
+              # `respond_to?(:value)` is too broad: `int`/`float` nodes respond to it
+              # but their value is a `Numeric`, which has no `to_sym` (e.g.
+              # `private_constant 42`). Only symbol/string arguments are real names.
+              argument.value.to_sym if argument.type?(:sym, :str)
             end
 
             constant_values.include?(node.name)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check that a copyright notice was given in each source file.
+      # Checks that a copyright notice was given in each source file.
       #
       # The default regexp for an acceptable copyright notice can be found in
       # config/default.yml. The default can be changed as follows:
@@ -46,15 +46,16 @@ module RuboCop
           token = insert_notice_before(processed_source)
           range = token.nil? ? range_between(0, 0) : token.pos
 
-          corrector.insert_before(range, "#{autocorrect_notice}\n")
+          corrector.insert_before(range, "#{normalized_autocorrect_notice}\n")
         end
 
-        def notice
-          cop_config['Notice']
-        end
+        def normalized_autocorrect_notice
+          autocorrect_notice.lines.map do |line|
+            next line if line.start_with?('#')
+            next "#\n" if line.chomp.empty?
 
-        def autocorrect_notice
-          cop_config['AutocorrectNotice']
+            "# #{line}"
+          end.join
         end
 
         def verify_autocorrect_notice!
@@ -62,8 +63,7 @@ module RuboCop
             raise Warning, "#{cop_name}: #{AUTOCORRECT_EMPTY_WARNING}"
           end
 
-          regex = Regexp.new(notice)
-          return if autocorrect_notice.gsub(/^# */, '').match?(regex)
+          return if normalized_autocorrect_notice.gsub(/^# */, '').match?(notice_regexp)
 
           message = "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
           raise Warning, "#{cop_name}: #{message}"
@@ -91,18 +91,29 @@ module RuboCop
         end
 
         def notice_found?(processed_source)
-          notice_regexp = Regexp.new(notice.lines.map(&:strip).join)
           multiline_notice = +''
           processed_source.tokens.each do |token|
             break unless token.comment?
 
-            multiline_notice << token.text.sub(/\A# */, '')
+            multiline_notice << token.text.sub(/\A# */, '') << "\n"
 
             break if notice_regexp.match?(token.text)
           end
 
           multiline_notice.match?(notice_regexp)
         end
+
+        def notice_regexp
+          @notice_regexp ||= Regexp.new(notice.sub(/\A(?:\\A|\^)?#(?:\\s[*+?]?|\s)*/, ''))
+        end
+
+        def notice
+          cop_config['Notice']
+        end
+
+        def autocorrect_notice
+          cop_config['AutocorrectNotice']
+        end
       end
     end
   end

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for consistent usage of the `DateTime` class over the
-      # `Time` class. This cop is disabled by default since these classes,
+      # Checks for consistent usage of the `Time` class over the
+      # `DateTime` class. This cop is disabled by default since these classes,
       # although highly overlapping, have particularities that make them not
       # replaceable in certain situations when dealing with multiple timezones
       # and/or DST.
@@ -59,12 +59,12 @@ module RuboCop
 
         # @!method historic_date?(node)
         def_node_matcher :historic_date?, <<~PATTERN
-          (send _ _ _ (const (const {nil? (cbase)} :Date) _))
+          (call _ _ _ (const (const {nil? (cbase)} :Date) _))
         PATTERN
 
         # @!method to_datetime?(node)
         def_node_matcher :to_datetime?, <<~PATTERN
-          (call _ :to_datetime)
+          (call !nil? :to_datetime)
         PATTERN
 
         def on_send(node)

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

@@ -79,6 +79,11 @@ module RuboCop
             corrector.replace(range, replacement)
 
             comments_in_range(node).reverse_each do |comment|
+              # Only relocate comments that the replacement destroys. A trailing
+              # comment after the chain survives in place, so moving it would
+              # duplicate it (and splitting the line drops the indentation).
+              next if comment.source_range.begin_pos >= range.end_pos
+
               corrector.insert_before(node, "#{comment.source}\n")
             end
           end