rubocop 1.71.1 → 1.88.2

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

@@ -29,25 +29,30 @@ module RuboCop
       # @example IgnoreModules: false (default)
       #   # bad
       #   class Foo
-      #     MyClass = Struct.new()
+      #     MyClass = Struct.new
       #   end
       #
       #   # good
       #   class Foo
-      #     MyClass = Struct.new()
+      #     MyClass = Struct.new
       #     public_constant :MyClass
       #   end
       #
       # @example IgnoreModules: true
       #   # good
       #   class Foo
-      #     MyClass = Struct.new()
+      #     MyClass = Struct.new
       #   end
       #
       class ConstantVisibility < Base
         MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
               'either `#public_constant` or `#private_constant`.'
 
+        # @!method visibility_declaration_for(node)
+        def_node_matcher :visibility_declaration_for, <<~PATTERN
+          (send nil? {:public_constant :private_constant} $...)
+        PATTERN
+
         def on_casgn(node)
           return unless class_or_module_scope?(node)
           return if visibility_declaration?(node)
@@ -77,20 +82,23 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def visibility_declaration?(node)
           node.parent.each_child_node(:send).any? do |child|
-            visibility_declaration_for?(child, node.name)
-          end
-        end
+            next false unless (arguments = visibility_declaration_for(child))
 
-        # @!method visibility_declaration_for?(node, const_name)
-        def_node_matcher :visibility_declaration_for?, <<~PATTERN
-          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
-        PATTERN
+            arguments = arguments.first.children.first.to_a if arguments.first&.splat_type?
+            constant_values = arguments.map do |argument|
+              # `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
 
-        def match_name?(name, constant_name)
-          name.to_sym == constant_name.to_sym
+            constant_values.include?(node.name)
+          end
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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/data_inheritance.rb

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Checks for inheritance from `Data.define` to avoid creating the anonymous parent class.
+      # Inheriting from `Data.define` adds a superfluous level in inheritance tree.
       #
       # @safety
       #   Autocorrection is unsafe because it will change the inheritance
@@ -17,12 +18,18 @@ module RuboCop
       #     end
       #   end
       #
+      #   Person.ancestors
+      #   # => [Person, #<Class:0x000000010b4e14a0>, Data, (...)]
+      #
       #   # good
       #   Person = Data.define(:first_name, :last_name) do
       #     def age
       #       42
       #     end
       #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, Data, (...)]
       class DataInheritance < Base
         include RangeHelp
         extend AutoCorrector
@@ -54,6 +61,10 @@ module RuboCop
 
         def correct_parent(parent, corrector)
           if parent.block_type?
+            # Convert a brace block to `do`, so the class's own `end` closes it
+            # once the closing delimiter is removed; otherwise a dangling `{` is
+            # left behind, producing invalid Ruby.
+            corrector.replace(parent.loc.begin, 'do') if parent.braces?
             corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))
           elsif (class_node = parent.parent).body.nil?
             corrector.remove(range_for_empty_class_body(class_node, parent))

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/def_with_parentheses.rb

@@ -25,8 +25,9 @@ module RuboCop
       #   # good
       #   def foo = do_something
       #
-      #   # good (without parentheses it's a syntax error)
+      #   # good - without parentheses it's a syntax error
       #   def foo() do_something end
+      #   def foo()=do_something
       #
       #   # bad
       #   def Baz.foo()
@@ -38,19 +39,35 @@ module RuboCop
       #     do_something
       #   end
       class DefWithParentheses < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = "Omit the parentheses in defs when the method doesn't accept any arguments."
 
         def on_def(node)
-          return if node.single_line? && !node.endless?
-          return unless !node.arguments? && (node_arguments = node.arguments.source_range)
+          return unless !node.arguments? && (arguments_range = node.arguments.source_range)
+          return if parentheses_required?(node, arguments_range)
 
-          add_offense(node_arguments) do |corrector|
-            corrector.remove(node_arguments)
+          add_offense(arguments_range) do |corrector|
+            corrector.remove(arguments_range)
           end
         end
         alias on_defs on_def
+
+        private
+
+        def parentheses_required?(node, arguments_range)
+          end_pos = arguments_range.end.end_pos
+          token_after_argument = range_between(end_pos, end_pos + 1).source
+
+          # A `;` after the parentheses (e.g. `def foo(); end`) already separates the
+          # signature from the body, so the parentheses can be removed (`def foo; end`).
+          return false if token_after_argument == ';'
+
+          return true if node.single_line? && !node.endless?
+
+          token_after_argument == '='
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for chained `dig` calls that can be collapsed into a single `dig`.
+      # Checks for chained `dig` calls that can be collapsed into a single `dig`.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -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

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

@@ -35,6 +35,10 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          # A trailing block (e.g. `Dir.each_child(path).none? { ... }`) changes
+          # the meaning and is not equivalent to `Dir.empty?`.
+          return if node.block_literal?
+
           offensive?(node) do |const_node, arg_node|
             replacement = "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})"
             add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|

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

@@ -6,7 +6,7 @@ module RuboCop
   module Cop
     module Style
       # Detects comments to enable/disable RuboCop.
-      # This is useful if want to make sure that every RuboCop error gets fixed
+      # This is useful if you want to make sure that every RuboCop error gets fixed
       # and not quickly disabled with a comment.
       #
       # Specific cops can be allowed with the `AllowedCops` configuration. Note that

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

@@ -161,7 +161,12 @@ module RuboCop
           source = source.gsub(COMMENT_REGEXP, '')
           return if source.blank?
 
-          /\s*#{Regexp.escape(source.strip)}/
+          # Treat `\#` (an escaped interpolation marker in the heredoc) as matching
+          # either `\#` or `#` in the comment, since the comment may show either
+          # the literal source form or the runtime appearance.
+          segments = source.strip.split('\\#', -1).map { |segment| Regexp.escape(segment) }
+
+          /\s*#{segments.join('\\\\?#')}/
         end
       end
     end

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

@@ -62,12 +62,12 @@ module RuboCop
       #
       # @example AllowedConstants: ['ClassMethods']
       #
-      #    # good
-      #    module A
-      #      module ClassMethods
-      #        # ...
-      #      end
-      #    end
+      #   # good
+      #   module A
+      #     module ClassMethods
+      #       # ...
+      #     end
+      #   end
       #
       class Documentation < Base
         include DocumentationComment

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
@@ -140,7 +140,11 @@ module RuboCop
         end
 
         def method_allowed?(node)
-          allowed_methods.include?(node.method_name)
+          # For a modifier form like `module_function def foo; end`, `node` is the
+          # `module_function`/`ruby2_keywords` send; the real method name is on its
+          # `def`/`defs` argument, not the modifier itself.
+          method_name = node.send_type? ? node.first_argument.method_name : node.method_name
+          allowed_methods.include?(method_name)
         end
 
         def allowed_methods

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

@@ -96,20 +96,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
           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
           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,7 +40,7 @@ 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
         def on_case(case_node)
@@ -90,7 +90,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
           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
 

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

@@ -107,12 +107,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