rubocop 1.71.1 → 1.92.0

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

@@ -23,6 +23,7 @@ module RuboCop
       #   list.push(qux, quux, corge)
       #
       class ConcatArrayLiterals < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
@@ -30,7 +31,15 @@ module RuboCop
           'Use `push` with elements as arguments without array brackets instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[concat].freeze
 
-        # rubocop:disable Metrics
+        # `Style/MethodCallWithArgsParentheses` removing the parentheses of the `push(...)`
+        # this cop writes in the same pass drops the line continuation a multiline call needs.
+        # `Style/TrailingCommaInArguments` adds a comma after the array literal this cop
+        # replaces with its elements in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::TrailingCommaInArguments]
+        end
+
+        # rubocop:disable-next Metrics
         def on_send(node)
           return if node.arguments.empty?
           return unless node.arguments.all?(&:array_type?)
@@ -52,17 +61,18 @@ module RuboCop
 
           add_offense(offense, message: message) do |corrector|
             if use_percent_literal
-              corrector.replace(offense, prefer)
+              next unless prefer
+
+              rebuild_call(corrector, 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.
+              rebuild_call(corrector, offense, preferred_method(node))
             else
-              corrector.replace(node.loc.selector, 'push')
-              node.arguments.each do |argument|
-                corrector.remove(argument.loc.begin)
-                corrector.remove(argument.loc.end)
-              end
+              remove_brackets(corrector, node)
             end
           end
         end
-        # rubocop:enable Metrics
         alias on_csend on_send
 
         private
@@ -73,7 +83,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
@@ -89,6 +99,40 @@ module RuboCop
             arg.children.all? { |child| child.type?(:str, :sym) }
           end
         end
+
+        def rebuild_call(corrector, offense, replacement)
+          # The comments inside the call would be lost.
+          return if comment_in?(offense)
+
+          corrector.replace(offense, replacement)
+        end
+
+        def comment_in?(range)
+          processed_source.each_comment_in_lines(range.line..range.last_line).any? do |comment|
+            range.contains?(comment.source_range)
+          end
+        end
+
+        def remove_brackets(corrector, node)
+          closing_ranges = node.arguments.map { |argument| closing_bracket_range(node, argument) }
+          # A comment or a heredoc body there can't be moved out of the way.
+          return unless closing_ranges.all? { |range| range.source.match?(/\A[\s,]*\]\z/) }
+
+          corrector.replace(node.loc.selector, 'push')
+          node.arguments.zip(closing_ranges) do |argument, closing_range|
+            corrector.remove(argument.loc.begin)
+            corrector.remove(closing_range)
+          end
+        end
+
+        # Whatever sits between the last element and the `]` of an array that isn't the
+        # last argument would end up before the following comma (a newline before it is a
+        # syntax error), so it's removed along with the `]`.
+        def closing_bracket_range(node, argument)
+          return argument.loc.end if argument.equal?(node.last_argument)
+
+          range_between(argument.children.last.source_range.end_pos, argument.loc.end.end_pos)
+        end
       end
     end
   end

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
@@ -111,7 +107,7 @@ module RuboCop
         end
       end
 
-      # Check for `if` and `case` statements where each branch is used for
+      # Checks for `if` and `case` statements where each branch is used for
       # both the assignment and comparison of the same variable
       # when using the return of the condition can be used instead.
       #
@@ -207,15 +203,14 @@ module RuboCop
       class ConditionalAssignment < Base
         include ConditionalAssignmentHelper
         include ConfigurableEnforcedStyle
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Use the return of the conditional for variable assignment and comparison.'
         ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals.'
         VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
-        LINE_LENGTH = 'Layout/LineLength'
         ENABLED = 'Enabled'
-        MAX = 'Max'
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'
 
         # The shovel operator `<<` does not have its own type. It is a `send`
@@ -228,6 +223,10 @@ module RuboCop
           }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         ASSIGNMENT_TYPES.each do |type|
           define_method :"on_#{type}" do |node|
             return if part_of_ignored_node?(node)
@@ -289,8 +288,12 @@ 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])
+          return unless safe_to_correct?(node)
 
           add_offense(node, message: ASSIGN_TO_CONDITION_MSG) do |corrector|
             autocorrect(corrector, node)
@@ -314,6 +317,7 @@ module RuboCop
 
         def assignment_node(node)
           assignment = node.send_type? ? node.last_argument : node.expression
+          return unless assignment
 
           # ignore pseudo-assignments without rhs in for nodes
           return if node.parent&.for_type?
@@ -369,6 +373,7 @@ module RuboCop
           return unless allowed_statements?(branches)
           return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
+          return unless safe_to_correct?(node)
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
@@ -381,6 +386,25 @@ module RuboCop
           end
         end
 
+        # The correction rewrites the conditional structurally, so full AST
+        # equivalence cannot be asserted, but the result must at least reparse
+        # to valid Ruby. Applying the correction to a throwaway buffer here
+        # also exercises the branch-shape handling before an offense is even
+        # reported, so unusual branches that the corrector cannot handle are
+        # left alone instead of crashing or emitting invalid code - the bug
+        # class behind most of this cop's history.
+        def safe_to_correct?(node)
+          correction_parses?(node)
+        rescue StandardError
+          false
+        end
+
+        # `ReparsedEquivalence#correction_parses?` contract: apply the exact
+        # correction this cop would perform.
+        def apply_reparse_correction(corrector, node)
+          autocorrect(corrector, node)
+        end
+
         def allowed_statements?(branches)
           return false unless branches.all?
 
@@ -398,7 +422,7 @@ module RuboCop
         # of the longest line + the length of the corrected assignment is
         # greater than the max configured line length
         def correction_exceeds_line_limit?(node, branches)
-          return false unless line_length_cop_enabled?
+          return false unless config.cop_enabled?('Layout/LineLength')
 
           assignment = lhs(tail(branches[0]))
 
@@ -416,14 +440,6 @@ module RuboCop
           assignment + longest_line
         end
 
-        def line_length_cop_enabled?
-          config.for_cop(LINE_LENGTH)[ENABLED]
-        end
-
-        def max_line_length
-          config.for_cop(LINE_LENGTH)[MAX]
-        end
-
         def single_line_conditions_only?
           cop_config[SINGLE_LINE_CONDITIONS_ONLY]
         end
@@ -436,26 +452,40 @@ module RuboCop
       # Helper module to provide common methods to ConditionalAssignment
       # correctors
       module ConditionalCorrectorHelper
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
             next if child.source_range.nil?
+            next if child.parent.dstr_type?
 
             white_space = white_space_range(child, column)
-            corrector.remove(white_space) if white_space.source.strip.empty?
+            corrector.remove(white_space) if white_space
           end
 
-          [condition.loc.else, condition.loc.end].each do |loc|
-            next unless loc
-
-            corrector.remove_preceding(loc, loc.column - column)
+          if condition.loc.else && !same_line?(condition.else_branch, condition)
+            corrector.remove_preceding(condition.loc.else, condition.loc.else.column - column)
           end
+
+          return unless condition.loc.end && !same_line?(
+            condition.branches.last.parent.else_branch, condition.loc.end
+          )
+
+          corrector.remove_preceding(condition.loc.end, condition.loc.end.column - column)
+        end
+
+        def same_line?(node1, node2)
+          RuboCop::Cop::Util.same_line?(node1, node2)
         end
 
         def white_space_range(node, column)
           expression = node.source_range
-          begin_pos = expression.begin_pos - (expression.column - column - 2)
+          end_pos = expression.begin_pos
+          begin_pos = end_pos - (expression.column - column - 2)
+
+          return nil if begin_pos > end_pos
 
-          Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
+          white_space = Parser::Source::Range.new(expression.source_buffer, begin_pos, end_pos)
+          white_space if white_space.source.strip.empty?
         end
 
         def assignment(node)
@@ -595,6 +625,8 @@ module RuboCop
 
             return unless (branch_else = branch.parent.loc.else)
 
+            return if same_line?(branch_else, condition)
+
             corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end
@@ -653,6 +685,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

@@ -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,19 +82,25 @@ module RuboCop
           end
         end
 
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         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
+            if (splat = arguments.first)&.splat_type?
+              next true unless splat.children.first.array_type?
+
+              arguments = splat.children.first.children
+            end
+            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
       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:
@@ -25,16 +25,20 @@ module RuboCop
         MSG = 'Include a copyright notice matching /%<notice>s/ before any code.'
         AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in your RuboCop config'
 
+        # rubocop:disable-next Metrics/AbcSize
         def on_new_investigation
           return if notice.empty? || notice_found?(processed_source)
 
-          verify_autocorrect_notice!
           message = format(MSG, notice: notice)
           if processed_source.blank?
             add_global_offense(message)
           else
             offense_range = source_range(processed_source.buffer, 1, 0)
             add_offense(offense_range, message: message) do |corrector|
+              next unless autocorrect?
+
+              verify_autocorrect_notice!
+
               autocorrect(corrector)
             end
           end
@@ -46,15 +50,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 +67,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 +95,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,11 +4,16 @@ 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
       #   tree (e.g. return value of `Module#ancestors`) of the constant.
       #
+      #   It is also unsafe because constants that the class body resolves through its
+      #   ancestors (e.g. one provided by an included module) fall out of scope inside
+      #   the block.
+      #
       # @example
       #   # bad
       #   class Person < Data.define(:first_name, :last_name)
@@ -17,12 +22,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
@@ -35,6 +46,7 @@ module RuboCop
 
         def on_class(node)
           return unless data_define?(node.parent_class)
+          return if defines_constants?(node.body)
 
           add_offense(node.parent_class) do |corrector|
             corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
@@ -52,8 +64,21 @@ module RuboCop
 
         private
 
+        # Constants, including nested classes and modules, are scoped to the class when they
+        # are defined in a class body, but leak into the enclosing namespace once moved into a
+        # `Data.define` block, so such a class cannot be rewritten as an assignment.
+        def defines_constants?(class_body)
+          return false unless class_body
+
+          class_body.each_node(:casgn, :class, :module).any?
+        end
+
         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|