rubocop 1.91.0 → 1.92.1

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,6 +31,14 @@ module RuboCop
           'Use `push` with elements as arguments without array brackets instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[concat].freeze
 
+        # `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?
@@ -54,17 +63,13 @@ module RuboCop
             if use_percent_literal
               next unless prefer
 
-              corrector.replace(offense, 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.
-              corrector.replace(offense, preferred_method(node))
+              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
@@ -94,6 +99,52 @@ 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/) }
+
+          replace_selector(corrector, node)
+
+          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
+
+        def replace_selector(corrector, node)
+          if node.parenthesized? || node.single_line?
+            corrector.replace(node.loc.selector, 'push')
+          else
+            range = node.loc.selector.join(node.first_argument.source_range.begin)
+
+            corrector.replace(range, 'push(')
+            corrector.insert_after(node.last_argument.loc.end, ')')
+          end
+        end
       end
     end
   end

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

@@ -223,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)

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

@@ -33,7 +33,8 @@ module RuboCop
       # a `--` trailing justification comment is allowed, so a team can require
       # every disable to be documented instead of banning them outright. Enable
       # directives are not checked in this mode, since they end a suppression
-      # rather than start one.
+      # rather than start one. Offenses in this mode are not autocorrected,
+      # since only a human can supply the missing justification.
       #
       # This cop cannot be disabled via directive comments when it is explicitly
       # enabled with `Enabled: true`. This prevents users from bypassing the cop
@@ -99,6 +100,8 @@ module RuboCop
                              'comment are not permitted.'
 
         def on_new_investigation
+          @matching_pops = nil
+
           processed_source.comments.each do |comment|
             directive = DirectiveComment.new(comment)
             next if ignored?(directive)
@@ -108,7 +111,7 @@ module RuboCop
 
             next unless disallowed_cops.any?
 
-            register_offense(comment, directive_cops, disallowed_cops)
+            register_offense(directive, directive_cops, disallowed_cops)
           end
         end
 
@@ -126,19 +129,61 @@ module RuboCop
           end
         end
 
-        def register_offense(comment, directive_cops, disallowed_cops)
-          add_offense(comment, message: offense_message(disallowed_cops)) do |corrector|
-            replacement = ''
+        def register_offense(directive, directive_cops, disallowed_cops)
+          comment = directive.comment
 
-            if directive_cops.length != disallowed_cops.length
-              replacement = comment.text.sub(/#{Regexp.union(disallowed_cops)},?\s*/, '')
-                                   .sub(/,\s*$/, '')
+          add_offense(comment, message: offense_message(disallowed_cops)) do |corrector|
+            # The remedy in `AllowWithReason` mode is to write the missing `--` justification,
+            # which cannot be autocorrected. Removing the directive would also unsuppress
+            # the disabled cops and let their autocorrections rewrite the annotated code.
+            next if allow_with_reason?
+
+            if directive_cops.length == disallowed_cops.length
+              remove_directive(corrector, directive)
+            elsif signed_args?(directive)
+              remove_signed_args(corrector, directive, disallowed_cops)
+            else
+              remove_cops(corrector, comment, disallowed_cops)
             end
+          end
+        end
+
+        # A `push` without its `pop` leaves an orphan `pop` behind, so the pair goes together.
+        def remove_directive(corrector, directive)
+          corrector.replace(directive.comment, '')
+          return unless directive.push? && (pop = matching_pop(directive.comment))
+
+          corrector.replace(pop, '')
+        end
+
+        def matching_pop(push_comment)
+          @matching_pops ||= pair_pushes_with_pops
+          @matching_pops[push_comment]
+        end
 
-            corrector.replace(comment, replacement)
+        def pair_pushes_with_pops
+          pushes = []
+          processed_source.comments.each_with_object({}) do |comment, pairs|
+            directive = DirectiveComment.new(comment)
+            if directive.push?
+              pushes.push(comment)
+            elsif directive.pop? && (push = pushes.pop)
+              pairs[push] = comment
+            end
           end
         end
 
+        def remove_signed_args(corrector, directive, disallowed_cops)
+          range = directive.range
+          names = Regexp.union(disallowed_cops)
+          corrector.replace(range, range.source.gsub(/\s+[+-]#{names}(?!\S)/, ''))
+        end
+
+        def remove_cops(corrector, comment, disallowed_cops)
+          corrector.replace(comment, comment.text.sub(/#{Regexp.union(disallowed_cops)},?\s*/, '')
+                                                 .sub(/,\s*$/, ''))
+        end
+
         def offense_message(disallowed_cops)
           if allow_with_reason?
             MSG_MISSING_REASON
@@ -150,10 +195,16 @@ module RuboCop
         end
 
         def directive_cops(directive)
+          return directive.signed_args.values.flatten if signed_args?(directive)
+
           match_captures = directive.match_captures
           match_captures && match_captures[1] ? match_captures[1].split(',').map(&:strip) : []
         end
 
+        def signed_args?(directive)
+          directive.push? || directive.next?
+        end
+
         def ignored?(directive)
           return true if exempt_mode?(directive)
 
@@ -169,6 +220,11 @@ module RuboCop
         end
 
         def allow_with_reason?
+          # TODO: The obsolete `AllowTrailingComment` is honored for backward compatibility
+          # and will be removed in RuboCop 2.0.
+          allow_trailing_comment = cop_config['AllowTrailingComment'] # rubocop:disable InternalAffairs/UndefinedConfig -- obsolete key, gone from default.yml on purpose
+          return allow_trailing_comment unless allow_trailing_comment.nil?
+
           cop_config['AllowWithReason']
         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))
 

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

@@ -103,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

@@ -102,8 +102,10 @@ module RuboCop
           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)

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

@@ -45,6 +45,8 @@ module RuboCop
         MSG_TRAILING_CONDITIONAL = 'Do not use trailing conditionals in string interpolation.'
         MSG_TERNARY = 'Do not return empty strings in string interpolation.'
 
+        INTERPOLATED_TYPES = %i[dstr dsym regexp xstr].freeze
+
         def on_interpolation(node)
           node.each_child_node(:if) do |child_node|
             if style == :trailing_conditional
@@ -63,28 +65,54 @@ module RuboCop
           return if child_node.modifier_form?
 
           if empty_if_outcome?(child_node)
-            ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
+            ternary_style_autocorrect(child_node, child_node.else_branch, 'unless')
           end
 
           return unless empty_else_outcome?(child_node)
 
-          ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
+          ternary_style_autocorrect(child_node, child_node.if_branch, '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}}")
+            next if nested_trailing_conditional?(child_node)
+
+            autocorrect_to_ternary(corrector, child_node)
+          end
+        end
+
+        def nested_trailing_conditional?(if_node)
+          if_node.each_descendant(:if).any? do |node|
+            node.modifier_form? && node.parent.parent&.type?(*INTERPOLATED_TYPES)
           end
         end
 
+        def autocorrect_to_ternary(corrector, if_node)
+          condition = if_node.condition.source
+          branch = ternary_branch_source(if_node.if_branch)
+          outcomes = if_node.unless? ? "'' : #{branch}" : "#{branch} : ''"
+
+          corrector.replace(if_node, "#{condition} ? #{outcomes}")
+        end
+
+        def ternary_branch_source(branch)
+          return branch.source unless command_call?(branch)
+
+          arguments = branch.first_argument.source_range.join(branch.last_argument.source_range)
+          method = branch.source_range.begin.join(arguments.begin).source.rstrip
+
+          "#{method}(#{arguments.source})"
+        end
+
+        def command_call?(node)
+          return false unless node.type?(:call, :super, :yield) && node.arguments?
+          return false if node.call_type? && (node.operator_method? || node.setter_method?)
+
+          !node.parenthesized?
+        end
+
         def empty_if_outcome?(node)
           empty_branch_outcome?(node.if_branch)
         end
@@ -99,9 +127,23 @@ module RuboCop
           branch.nil_type? || (branch.str_type? && branch.value.empty?)
         end
 
-        def ternary_style_autocorrect(node, outcome, condition)
+        def ternary_style_autocorrect(node, outcome, keyword)
           add_offense(node, message: MSG_TERNARY) do |corrector|
-            corrector.replace(node, "#{outcome} #{condition} #{node.condition.source}")
+            next if empty_string_conditional_in_condition?(node)
+
+            head = node.source_range.begin.join(outcome.source_range.begin)
+            tail = outcome.source_range.end.join(node.source_range.end)
+
+            corrector.remove(head)
+            corrector.replace(tail, " #{keyword} #{node.condition.source}")
+          end
+        end
+
+        def empty_string_conditional_in_condition?(if_node)
+          if_node.condition.each_descendant(:if).any? do |node|
+            next false if node.modifier_form? || !node.parent.parent&.type?(*INTERPOLATED_TYPES)
+
+            empty_if_outcome?(node) || empty_else_outcome?(node)
           end
         end
       end

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

@@ -131,7 +131,9 @@ module RuboCop
       #
       class EndlessMethod < Base
         include ConfigurableEnforcedStyle
+        include LineLengthHelp
         include EndlessMethodRewriter
+        include EndlessMethodBodyHelp
         extend TargetRubyVersion
         extend AutoCorrector
 
@@ -143,6 +145,16 @@ module RuboCop
         MSG_REQUIRE_SINGLE = 'Use endless method definitions for single line methods.'
         MSG_REQUIRE_ALWAYS = 'Use endless method definitions.'
 
+        # `Style/MethodDefParentheses` adds the same parentheses a parameter list needs in
+        # an endless definition, so letting both correct in the same pass would double them.
+        # `Style/GuardClause` turns a single `if` body into several statements,
+        # which an endless definition cannot hold.
+        # `Style/RaiseArgs` would drop the parentheses of a `raise` that becomes
+        # the body in the same pass, which a method passed as an argument needs.
+        def self.autocorrect_incompatible_with
+          [Style::GuardClause, Style::MethodCallWithArgsParentheses, Style::MethodDefParentheses, Style::RaiseArgs]
+        end
+
         def on_def(node)
           return if node.assignment_method? || use_heredoc?(node)
 
@@ -213,12 +225,26 @@ module RuboCop
           return false unless (body = node.body)
           return true if body.any_str_type? && body.heredoc?
 
-          body.each_descendant(:str).any?(&:heredoc?)
+          body.each_descendant(:any_str).any?(&:heredoc?)
         end
 
         def correct_to_endless(corrector, node)
-          corrector.replace(signature_to_body_range(node), ' = ')
-          corrector.remove(node.body.source_range.end.join(node.loc.end.end))
+          if unparenthesized_arguments?(node)
+            corrector.replace(name_to_arguments_range(node), '(')
+            corrector.replace(signature_to_body_range(node), ') = ')
+          else
+            corrector.replace(signature_to_body_range(node), ' = ')
+          end
+
+          corrector.remove(body_to_end_range(node))
+        end
+
+        def unparenthesized_arguments?(node)
+          node.arguments.any? && !node.arguments.loc.begin
+        end
+
+        def name_to_arguments_range(node)
+          node.loc.name.end.join(node.arguments.source_range.begin)
         end
 
         def signature_to_body_range(node)
@@ -227,6 +253,10 @@ module RuboCop
           signature_end.join(node.body.source_range.begin)
         end
 
+        def body_to_end_range(node)
+          node.body.source_range.end.join(node.loc.end.end)
+        end
+
         def endless_replacement(node)
           <<~RUBY.strip
             def #{receiver(node)}#{node.method_name}#{arguments(node)} = #{node.body.source}
@@ -238,11 +268,29 @@ module RuboCop
         end
 
         def arguments(node, missing = '')
-          node.arguments.any? ? node.arguments.source : missing
+          return missing unless node.arguments.any?
+          return parenthesized_arguments(node) if unparenthesized_arguments?(node)
+
+          node.arguments.source
+        end
+
+        def parenthesized_arguments(node)
+          padding = space_inside_parens? ? ' ' : ''
+
+          "(#{padding}#{node.arguments.source}#{padding})"
+        end
+
+        def space_inside_parens?
+          return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+          config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle'] != 'no_space'
         end
 
         def can_be_made_endless?(node)
-          node.body && !node.body.type?(:begin, :kwbegin, :rescue, :ensure)
+          return false unless node.body
+          return false if comment_in_discarded_range?(node)
+
+          endless_method_body?(node.body)
         end
 
         def single_line_when_made_endless?(node)
@@ -252,7 +300,24 @@ module RuboCop
         def too_long_when_made_endless?(node)
           return false unless config.cop_enabled?('Layout/LineLength')
 
-          endless_replacement(node).length + node.loc.column > max_line_length
+          line_length(line_when_made_endless(node)) > max_line_length
+        end
+
+        def comment_in_discarded_range?(node)
+          discarded_ranges = [signature_to_body_range(node), body_to_end_range(node)]
+
+          processed_source.each_comment_in_lines(node.first_line..node.last_line).any? do |comment|
+            discarded_ranges.any? { |range| range.contains?(comment.source_range) }
+          end
+        end
+
+        def line_when_made_endless(node)
+          keyword_element = node.loc.keyword
+          code_before = keyword_element.source_line[0...keyword_element.column]
+          end_element = node.loc.end
+          code_after = end_element.source_line[end_element.last_column..]
+
+          "#{code_before}#{endless_replacement(node)}#{code_after}"
         end
       end
     end

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

@@ -5,11 +5,15 @@ module RuboCop
     module Style
       # Checks for exact regexp match inside `Regexp` literals.
       #
+      # `=~` returns an index and `match` returns `MatchData`, so they are only
+      # autocorrected when their value is used as a condition. The same goes for
+      # safe navigation calls, which return `nil` for a `nil` receiver.
+      #
       # @example
       #
       #   # bad
       #   string =~ /\Astring\z/
-      #   string === /\Astring\z/
+      #   /\Astring\z/ === string
       #   string.match(/\Astring\z/)
       #   string.match?(/\Astring\z/)
       #
@@ -27,14 +31,15 @@ module RuboCop
 
         MSG = 'Use `%<prefer>s`.'
         RESTRICT_ON_SEND = %i[=~ === !~ match match?].freeze
+        BOOLEAN_METHODS = %i[=== !~ match?].to_set.freeze
 
+        # `String#===` is plain equality, so `===` only matches with the regexp as its receiver.
         # @!method exact_regexp_match(node)
         def_node_matcher :exact_regexp_match, <<~PATTERN
-          (call
-            _ {:=~ :=== :!~ :match :match?}
-            (regexp
-              (str $_)
-              (regopt)))
+          {
+            (call _ {:=~ :!~ :match :match?} (regexp (str $_) (regopt)))
+            (send (regexp (str $_) (regopt)) :=== _)
+          }
         PATTERN
 
         def on_send(node)
@@ -44,16 +49,48 @@ module RuboCop
           return unless exact_match_pattern?(parsed_regexp)
 
           string = escape_single_quotes(parsed_regexp[1].text)
-          prefer = "#{receiver.source} #{new_method(node)} '#{string}'"
+          subject = node.method?(:===) ? node.first_argument : receiver
+          prefer = "#{subject.source} #{new_method(node)} '#{string}'"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
-            corrector.replace(node, prefer)
+            autocorrect(corrector, node, prefer)
           end
         end
         alias on_csend on_send
 
         private
 
+        def autocorrect(corrector, node, prefer)
+          return unless boolean_result?(node) || truthiness_only?(node)
+
+          corrector.replace(node, parenthesize?(node) ? "(#{prefer})" : prefer)
+        end
+
+        # `=~` returns an index, `match` returns `MatchData` and `&.` can return `nil`,
+        # so replacing them with `==` is only safe where the value is used as a condition.
+        def boolean_result?(node)
+          node.send_type? && BOOLEAN_METHODS.include?(node.method_name)
+        end
+
+        def truthiness_only?(node)
+          return true unless node.value_used?
+
+          parent = node.parent
+          if parent.type?(:begin, :and, :or)
+            truthiness_only?(parent)
+          elsif parent.type?(:if, :while, :until)
+            parent.condition.equal?(node)
+          else
+            parent.send_type? && parent.method?(:!)
+          end
+        end
+
+        def parenthesize?(node)
+          return false unless (parent = node.parent)&.call_type?
+
+          parent.receiver.equal?(node) || (parent.operator_method? && !parent.method?(:[]))
+        end
+
         # Escape characters that are special inside a single-quoted string so the
         # generated literal (e.g. for `/\Afoo'bar\z/`) stays valid Ruby.
         def escape_single_quotes(text)