rubocop 1.71.1 → 1.92.0

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

@@ -97,14 +97,14 @@ module RuboCop
       #
       # @example AllowedMethods: ['method_missing', 'respond_to_missing?']
       #
-      #    # good
-      #    class Foo
-      #      def method_missing(name, *args)
-      #      end
+      #   # good
+      #   class Foo
+      #     def method_missing(name, *args)
+      #     end
       #
-      #      def respond_to_missing?(symbol, include_private)
-      #      end
-      #    end
+      #     def respond_to_missing?(symbol, include_private)
+      #     end
+      #   end
       #
       class DocumentationMethod < Base
         include DocumentationComment
@@ -119,6 +119,7 @@ module RuboCop
 
         def on_def(node)
           return if node.method?(:initialize)
+          return if allowed_methods.include?(node.method_name)
 
           parent = node.parent
           modifier_node?(parent) ? check(parent) : check(node)
@@ -130,7 +131,6 @@ module RuboCop
         def check(node)
           return if non_public?(node) && !require_for_non_public_methods?
           return if documentation_comment?(node)
-          return if method_allowed?(node)
 
           add_offense(node)
         end
@@ -139,10 +139,6 @@ module RuboCop
           cop_config['RequireForNonPublicMethods']
         end
 
-        def method_allowed?(node)
-          allowed_methods.include?(node.method_name)
-        end
-
         def allowed_methods
           @allowed_methods ||= cop_config.fetch('AllowedMethods', []).map(&:to_sym)
         end

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

@@ -70,6 +70,7 @@ module RuboCop
 
         def on_send(node)
           return unless double_negative?(node) && node.prefix_bang?
+          return if part_of_longer_negation?(node)
           return if style == :allowed_in_returns && allowed_in_returns?(node)
 
           location = node.loc.selector
@@ -81,10 +82,20 @@ module RuboCop
 
         private
 
+        def part_of_longer_negation?(node)
+          return true if negation?(node.parent) && node.parent.receiver.equal?(node)
+
+          negation?(node.receiver.receiver)
+        end
+
         def allowed_in_returns?(node)
           node.parent&.return_type? || end_of_method_definition?(node)
         end
 
+        def negation?(node)
+          node&.send_type? && node.method?(:!)
+        end
+
         def end_of_method_definition?(node)
           return false unless (def_node = find_def_node_from_ascendant(node))
 
@@ -96,20 +107,20 @@ module RuboCop
           elsif last_child.type?(:pair, :hash) || last_child.parent.array_type?
             false
           else
-            last_child.last_line <= node.last_line
+            last_child.first_line <= node.first_line
           end
         end
 
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
-          return parent if parent.type?(:def, :defs)
+          return parent if parent.any_def_type?
           return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)
         end
 
         def define_method?(node)
-          return false unless node.block_type?
+          return false unless node.any_block_type?
 
           child = node.child_nodes.first
           return false unless child.send_type?

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

@@ -26,7 +26,7 @@ module RuboCop
 
         MSG = 'Use `Integer#times` for a simple loop which iterates a fixed number of times.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- only matches blocks that take no parameters
           return unless offending?(node)
 
           send_node = node.send_node

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

@@ -40,6 +40,8 @@ module RuboCop
           end
         end
 
+        alias on_itblock on_block
+
         def on_numblock(node)
           each_with_object_numblock_candidate?(node) do |method, body|
             _, method_name, method_arg = *method
@@ -58,7 +60,7 @@ module RuboCop
 
         # @!method each_with_object_block_candidate?(node)
         def_node_matcher :each_with_object_block_candidate?, <<~PATTERN
-          (block $(call _ {:inject :reduce} _) $_ $_)
+          (block $(call _ {:inject :reduce} _) $(args _ _) $_)
         PATTERN
 
         # @!method each_with_object_numblock_candidate?(node)
@@ -71,8 +73,7 @@ module RuboCop
 
           first_arg, second_arg = *node.arguments
 
-          corrector.replace(first_arg, second_arg.source)
-          corrector.replace(second_arg, first_arg.source)
+          corrector.swap(first_arg, second_arg)
 
           if return_value_occupies_whole_line?(return_value)
             corrector.remove(whole_line_expression(return_value))

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

@@ -28,7 +28,7 @@ module RuboCop
 
         MSG = 'Omit pipes for the empty block parameters.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the offense is an empty `||`
           send_node = node.send_node
           check(node) unless send_node.send_type? && send_node.lambda_literal?
         end

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

@@ -40,9 +40,9 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not use empty `case` condition, instead use an `if` expression.'
-        NOT_SUPPORTED_PARENT_TYPES = %i[return break next send csend].freeze
+        NOT_SUPPORTED_PARENT_TYPES = %i[return break next send csend yield super].freeze
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_case(case_node)
           if case_node.condition || NOT_SUPPORTED_PARENT_TYPES.include?(case_node.parent&.type)
             return
@@ -56,7 +56,6 @@ module RuboCop
 
           add_offense(case_node.loc.keyword) { |corrector| autocorrect(corrector, case_node) }
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
@@ -90,7 +89,17 @@ module RuboCop
             range = range_between(conditions.first.source_range.begin_pos,
                                   conditions.last.source_range.end_pos)
 
-            corrector.replace(range, conditions.map(&:source).join(' || '))
+            corrector.replace(range, conditions.map { |c| parenthesize_condition(c) }.join(' || '))
+          end
+        end
+
+        # A condition that binds looser than `||` (e.g. a ternary, range, or
+        # assignment) must be parenthesized so the joined `||` keeps its meaning.
+        def parenthesize_condition(condition)
+          if condition.assignment? || condition.type?(:if, :and, :or, :range)
+            "(#{condition.source})"
+          else
+            condition.source
           end
         end
 

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces consistent style for empty class definitions.
+      #
+      # This cop can enforce either a standard class definition or `Class.new`
+      # for classes with no body.
+      #
+      # The supported styles are:
+      #
+      # * class_keyword (default) - prefer standard class definition over `Class.new`
+      # * class_new - prefer `Class.new` over class definition
+      #
+      # One difference between the two styles is that the `Class.new` form does not make
+      # the subclass name available to the base class's `inherited` callback.
+      # For this reason, `EnforcedStyle: class_keyword` is set as the default style.
+      # Class definitions without a superclass, which are not involved in inheritance,
+      # are not detected. This ensures safe detection regardless of the applied style.
+      # This avoids overlapping responsibilities with the `Lint/EmptyClass` cop.
+      #
+      # Use `AllowedParentClasses` to permit both styles for specific parent classes.
+      # For example, adding `StandardError` allows both `Error = Class.new(StandardError)`
+      # and `class Error < StandardError; end` regardless of the enforced style.
+      #
+      # @example EnforcedStyle: class_keyword (default)
+      #   # bad
+      #   FooError = Class.new(StandardError)
+      #
+      #   # okish
+      #   class FooError < StandardError; end
+      #
+      #   # good
+      #   class FooError < StandardError
+      #   end
+      #
+      # @example EnforcedStyle: class_new
+      #   # bad
+      #   class FooError < StandardError
+      #   end
+      #
+      #   # bad
+      #   class FooError < StandardError; end
+      #
+      #   # good
+      #   FooError = Class.new(StandardError)
+      #
+      # @example AllowedParentClasses: ['StandardError']
+      #   # good - allowed regardless of EnforcedStyle
+      #   FooError = Class.new(StandardError)
+      #
+      #   # good - allowed regardless of EnforcedStyle
+      #   class FooError < StandardError
+      #   end
+      #
+      class EmptyClassDefinition < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG_CLASS_KEYWORD =
+          'Use the `class` keyword instead of `Class.new` to define an empty class.'
+        MSG_CLASS_NEW = 'Use `Class.new` instead of the `class` keyword to define an empty class.'
+
+        # @!method class_new_assignment(node)
+        def_node_matcher :class_new_assignment, <<~PATTERN
+          (casgn _ _ $(send (const _ :Class) :new _))
+        PATTERN
+
+        def on_casgn(node)
+          return unless %i[class_keyword class_definition].include?(style)
+          return unless (class_new_node = class_new_assignment(node))
+          return if (arg = class_new_node.first_argument) && !arg.const_type?
+          return if allowed_parent_class?(class_new_node.first_argument.source)
+
+          add_offense(node, message: MSG_CLASS_KEYWORD) do |corrector|
+            autocorrect_class_new(corrector, node, class_new_node)
+          end
+        end
+
+        def on_class(node)
+          return unless style == :class_new
+          return unless node.parent_class
+          return if (body = node.body) && !body.children.empty?
+          return if allowed_parent_class?(node.parent_class.source)
+
+          add_offense(node, message: MSG_CLASS_NEW) do |corrector|
+            autocorrect_class_definition(corrector, node)
+          end
+        end
+
+        private
+
+        def allowed_parent_class?(parent_class_name)
+          allowed_parent_classes.include?(parent_class_name)
+        end
+
+        def allowed_parent_classes
+          cop_config.fetch('AllowedParentClasses', [])
+        end
+
+        def autocorrect_class_new(corrector, node, class_new_node)
+          indent = ' ' * node.loc.column
+          class_name = constant_name(node)
+          parent_class_name = class_new_node.first_argument.source
+
+          corrector.replace(node, "class #{class_name} < #{parent_class_name}\n#{indent}end")
+        end
+
+        # Preserve any namespace on the assigned constant (e.g. `Foo::Bar`),
+        # which `node.name` drops.
+        def constant_name(node)
+          namespace = node.namespace
+          namespace ? "#{namespace.source}::#{node.name}" : node.name
+        end
+
+        def autocorrect_class_definition(corrector, node)
+          class_name = node.identifier.source
+          parent_class_name = node.parent_class.source
+
+          corrector.replace(node, "#{class_name} = Class.new(#{parent_class_name})")
+        end
+      end
+    end
+  end
+end

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

@@ -42,6 +42,10 @@ module RuboCop
         MSG = 'Use an empty string literal instead of heredoc.'
 
         def on_heredoc(node)
+          # A backtick heredoc (`<<~`CMD``) executes a command, so it cannot be
+          # replaced with an empty string literal.
+          return if node.xstr_type?
+
           heredoc_body = node.loc.heredoc_body
 
           return unless heredoc_body.source.empty?

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

@@ -23,7 +23,7 @@ module RuboCop
 
         MSG = 'Omit parentheses for the empty lambda parameters.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the offense is an empty `()`
           send_node = node.send_node
           return unless send_node.send_type?
 

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

@@ -6,6 +6,10 @@ module RuboCop
       # Checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash, or string.
       #
+      # NOTE: When frozen string literals are enabled, `String.new`
+      # isn't corrected to an empty string since the former is
+      # mutable and the latter would be frozen.
+      #
       # @example
       #   # bad
       #   a = Array.new
@@ -40,13 +44,18 @@ module RuboCop
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
 
         # @!method array_with_block(node)
-        def_node_matcher :array_with_block, '(block (send (const {nil? cbase} :Array) :new) args _)'
+        def_node_matcher :array_with_block, <<~PATTERN
+          {
+            (block (send (const {nil? cbase} :Array) :new) args _)
+            ({numblock itblock} (send (const {nil? cbase} :Array) :new) ...)
+          }
+        PATTERN
 
         # @!method hash_with_block(node)
         def_node_matcher :hash_with_block, <<~PATTERN
           {
             (block (send (const {nil? cbase} :Hash) :new) args _)
-            (numblock (send (const {nil? cbase} :Hash) :new) ...)
+            ({numblock itblock} (send (const {nil? cbase} :Hash) :new) ...)
           }
         PATTERN
 
@@ -94,7 +103,7 @@ module RuboCop
         end
 
         def replacement_range(node)
-          if hash_node(node) && first_argument_unparenthesized?(node)
+          if offense_hash_node?(node) && first_argument_unparenthesized?(node)
             # `some_method {}` is not same as `some_method Hash.new`
             # because the braces are interpreted as a block. We will have
             # to rewrite the arguments to wrap them in parenthesis.

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

@@ -53,11 +53,11 @@ module RuboCop
 
         def on_def(node)
           return if node.body || processed_source.contains_comment?(node.source_range)
-          return if correct_style?(node)
+          return if correct_style?(node) || compact_style_disallowed?
 
           add_offense(node) do |corrector|
             correction = corrected(node)
-            next if compact_style? && max_line_length && correction.size > max_line_length
+            next if correction_exceeds_line_length?(correction)
 
             corrector.replace(node, correction)
           end
@@ -74,6 +74,12 @@ module RuboCop
           (compact_style? && compact?(node)) || (expanded_style? && expanded?(node))
         end
 
+        def compact_style_disallowed?
+          return false unless compact_style?
+
+          config.for_enabled_cop('Style/SingleLineMethods')['AllowIfMethodIsEmpty'] == false
+        end
+
         def corrected(node)
           scope = node.receiver ? "#{node.receiver.source}." : ''
           arguments = if node.arguments?
@@ -86,14 +92,20 @@ module RuboCop
           ["def #{signature}", 'end'].join(joint(node))
         end
 
+        def correction_exceeds_line_length?(correction)
+          compact_style? && max_line_length && correction.size > max_line_length
+        end
+
         def joint(node)
           indent = ' ' * node.loc.column
 
           compact_style? ? '; ' : "\n#{indent}"
         end
 
+        # A method with an argument spanning multiple lines (e.g. a hash default
+        # value) can't be put on a single line, so it's as compact as it gets.
         def compact?(node)
-          node.single_line?
+          node.single_line? || node.arguments.any?(&:multiline?)
         end
 
         def expanded?(node)
@@ -107,12 +119,6 @@ module RuboCop
         def expanded_style?
           style == :expanded
         end
-
-        def max_line_length
-          return unless config.cop_enabled?('Layout/LineLength')
-
-          config.for_cop('Layout/LineLength')['Max']
-        end
       end
     end
   end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for empty strings being assigned inside string interpolation.
+      #
+      # Empty strings are a meaningless outcome inside of string interpolation, so we remove them.
+      # Alternatively, when configured to do so, we prioritise using empty strings.
+      #
+      # While this cop would also apply to variables that are only going to be used as strings,
+      # RuboCop can't detect that, so we only check inside of string interpolation.
+      #
+      # @example EnforcedStyle: trailing_conditional (default)
+      #   # bad
+      #   "#{condition ? 'foo' : ''}"
+      #
+      #   # good
+      #   "#{'foo' if condition}"
+      #
+      #   # bad
+      #   "#{condition ? '' : 'foo'}"
+      #
+      #   # good
+      #   "#{'foo' unless condition}"
+      #
+      # @example EnforcedStyle: ternary
+      #   # bad
+      #   "#{'foo' if condition}"
+      #
+      #   # good
+      #   "#{condition ? 'foo' : ''}"
+      #
+      #   # bad
+      #   "#{'foo' unless condition}"
+      #
+      #   # good
+      #   "#{condition ? '' : 'foo'}"
+      #
+      class EmptyStringInsideInterpolation < Base
+        include ConfigurableEnforcedStyle
+        include Interpolation
+        extend AutoCorrector
+
+        MSG_TRAILING_CONDITIONAL = 'Do not use trailing conditionals in string interpolation.'
+        MSG_TERNARY = 'Do not return empty strings in string interpolation.'
+
+        def on_interpolation(node)
+          node.each_child_node(:if) do |child_node|
+            if style == :trailing_conditional
+              trailing_conditional_correction(child_node)
+            elsif style == :ternary
+              ternary_correction(node, child_node)
+            end
+          end
+        end
+
+        private
+
+        def trailing_conditional_correction(child_node)
+          # A modifier `if`/`unless` is already a trailing conditional and has
+          # no `else` branch, so the ternary-to-trailing rewrite does not apply.
+          return if child_node.modifier_form?
+
+          if empty_if_outcome?(child_node)
+            ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
+          end
+
+          return unless empty_else_outcome?(child_node)
+
+          ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
+        end
+
+        def ternary_correction(node, child_node)
+          return unless child_node.modifier_form?
+
+          ternary_component = if child_node.unless?
+                                "'' : #{child_node.if_branch.source}"
+                              else
+                                "#{child_node.if_branch.source} : ''"
+                              end
+
+          add_offense(node, message: MSG_TRAILING_CONDITIONAL) do |corrector|
+            corrector.replace(node, "\#{#{child_node.condition.source} ? #{ternary_component}}")
+          end
+        end
+
+        def empty_if_outcome?(node)
+          empty_branch_outcome?(node.if_branch)
+        end
+
+        def empty_else_outcome?(node)
+          empty_branch_outcome?(node.else_branch)
+        end
+
+        def empty_branch_outcome?(branch)
+          return false unless branch
+
+          branch.nil_type? || (branch.str_type? && branch.value.empty?)
+        end
+
+        def ternary_style_autocorrect(node, outcome, condition)
+          add_offense(node, message: MSG_TERNARY) do |corrector|
+            corrector.replace(node, "#{outcome} #{condition} #{node.condition.source}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,12 +3,18 @@
 module RuboCop
   module Cop
     module Style
-      # Checks ensures source files have no utf-8 encoding comments.
+      # Checks that source files have no utf-8 encoding comments.
+      # Since Ruby 2.0, UTF-8 is the default source encoding, so
+      # these comments are no longer necessary and just add noise.
+      #
       # @example
       #   # bad
       #   # encoding: UTF-8
       #   # coding: UTF-8
       #   # -*- coding: UTF-8 -*-
+      #
+      #   # good
+      #   # No encoding comment needed
       class Encoding < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for END blocks.
+      # Checks for `END` blocks. `END` blocks are Perl-style constructs
+      # and `Kernel#at_exit` is the idiomatic Ruby alternative, as it's
+      # explicit and can be used anywhere.
       #
       # @example
       #   # bad