rubocop 1.91.0 → 1.92.2

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

@@ -102,6 +102,7 @@ module RuboCop
           return replaced_node unless node.parent
           return "(#{replaced_node})" if node.parent.operator_keyword?
           return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
+          return "(#{replaced_node})" if parent_binds_tighter_than_ternary?(node)
 
           replaced_node
         end
@@ -124,6 +125,14 @@ module RuboCop
             "#{expr_replacement(else_branch)}"
         end
 
+        def parent_binds_tighter_than_ternary?(node)
+          parent = node.parent
+          return parent.receiver.equal?(node) if parent.call_type?
+          return parent.namespace.equal?(node) if parent.type?(:const, :casgn)
+
+          parent.if_type? && parent.ternary? && parent.condition.equal?(node)
+        end
+
         def expr_replacement(node)
           return 'nil' if node.nil?
 
@@ -131,7 +140,9 @@ module RuboCop
         end
 
         def requires_parentheses?(node)
-          return true if %i[and or if].include?(node.type)
+          return true if node.type?(
+            :and, :or, :if, :rescue, :while, :until, :while_post, :until_post, :any_match_pattern
+          )
           return true if node.assignment?
           return true if method_call_with_changed_precedence?(node)
 
@@ -139,7 +150,7 @@ module RuboCop
         end
 
         def method_call_with_changed_precedence?(node)
-          return false unless node.send_type? && node.arguments?
+          return false unless node.call_type? && node.arguments?
           return false if node.parenthesized_call?
 
           !node.operator_method?

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

@@ -83,7 +83,8 @@ module RuboCop
           control_op_condition(cond) do |first_child, rest_children|
             return if require_parentheses?(node, first_child)
             return if semicolon_separated_expressions?(first_child, rest_children)
-            return if modifier_op?(first_child)
+            return if modifier_op?(first_child) || first_child.masgn_type?
+            return if command_call_assignment?(first_child)
             return if parens_allowed?(cond)
 
             message = message(cond)
@@ -115,6 +116,23 @@ module RuboCop
           node.basic_conditional? && node.modifier_form?
         end
 
+        def command_call_assignment?(node)
+          return false if !node.assignment? && !setter_method?(node)
+
+          value = node.children.last
+          value = value.body if value.rescue_type?
+
+          command_call_assignment?(value) || command_call?(value)
+        end
+
+        def command_call?(node)
+          node = node.send_node if node.any_block_type?
+          return false if !node.type?(:call, :super, :yield) || !node.arguments?
+          return false if node.parenthesized? || node.operator_method? || node.setter_method?
+
+          !node.method?(:[])
+        end
+
         def message(node)
           kw = node.parent.keyword
           article = kw == 'while' ? 'a' : 'an'

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

@@ -86,10 +86,21 @@ module RuboCop
         end
 
         def include_same_character_as_used_for_delimiter?(node, type)
-          return false unless %w[%w %i].include?(type)
-
           used_delimiters = matchpairs(begin_source(node)[-1])
-          contains_delimiter?(node, used_delimiters)
+          return contains_delimiter?(node, used_delimiters) if %w[%w %i].include?(type)
+          return false unless %w[%q %s %r].include?(type)
+
+          contains_escaped_delimiter?(node, used_delimiters)
+        end
+
+        # Without interpolation an escaped delimiter means something different
+        # once the delimiters change (`%q!it\!s!` is `"it!s"`, but `%q(it\!s)`
+        # is `"it\\!s"`). For a regexp the match stays the same, but its source
+        # changes. Interpolating literals read `\!` as `!` with any delimiter.
+        def contains_escaped_delimiter?(node, delimiters)
+          body = node.loc.begin.end.join(node.loc.end.begin).source
+
+          body.scan(/\\./m).any? { |escape| delimiters.include?(escape[1]) }
         end
 
         def contains_delimiter?(node, delimiters)

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

@@ -86,14 +86,12 @@ module RuboCop
         end
 
         def correct_quotes(str)
-          correction = if style == :single_quotes
-                         to_string_literal(str)
-                       else
-                         str.gsub("\\'", "'").inspect
-                       end
-
           # The conversion process doubles escaped slashes, so they have to be reverted
-          correction.gsub('\\\\', '\\').gsub('\"', '"')
+          if style == :single_quotes
+            to_string_literal(str).gsub('\\\\', '\\').gsub('\"', '"')
+          else
+            str.gsub("\\'", "'").inspect.gsub('\\\\', '\\')
+          end
         end
 
         def style

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

@@ -74,7 +74,7 @@ module RuboCop
 
           arguments = [exception_node, message_node].compact.map(&:source).join(', ')
 
-          if node.parent && requires_parens?(node.parent)
+          if parenthesize?(node)
             "#{node.method_name}(#{arguments})"
           else
             "#{node.method_name} #{arguments}"
@@ -86,31 +86,60 @@ module RuboCop
           return if message_nodes.size > 1
 
           argument = message_nodes.first.source
-          exception_class = exception_node.receiver&.source || exception_node.source
+          exception_class = exception_class_node(exception_node).source
 
-          if node.parent && requires_parens?(node.parent)
+          if parenthesize?(node)
             "#{node.method_name}(#{exception_class}.new(#{argument}))"
           else
             "#{node.method_name} #{exception_class}.new(#{argument})"
           end
         end
 
+        def exception_class_node(exception_node)
+          use_new_method?(exception_node) ? exception_node.receiver : exception_node
+        end
+
         def check_compact(node)
           if node.arguments.size > 1
             exception = node.first_argument
             return if exception.send_type? && exception.first_argument&.hash_type?
+            return if use_new_method?(exception) && exception.arguments?
 
             add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
-              replacement = correction_exploded_to_compact(node)
-
-              corrector.replace(node, replacement)
-              opposite_style_detected
+              correct_raise(node) { correct_to_compact(corrector, node) }
             end
           else
             correct_style_detected
           end
         end
 
+        def correct_to_compact(corrector, node)
+          if heredoc_message?(node)
+            correct_heredoc_exploded_to_compact(corrector, node)
+          else
+            corrector.replace(node, correction_exploded_to_compact(node))
+          end
+        end
+
+        def heredoc_message?(node)
+          node.parenthesized? && node.arguments.size == 2 && heredoc?(node.last_argument)
+        end
+
+        def heredoc?(node)
+          node.each_node(:any_str).any?(&:heredoc?)
+        end
+
+        def correct_heredoc_exploded_to_compact(corrector, node)
+          exception_node, message_node = *node.arguments
+          exception_class = exception_class_node(exception_node)
+          corrector.replace(range_between(exception_class, message_node), '.new(')
+          corrector.insert_after(message_node, ')')
+        end
+
+        def range_between(left_node, right_node)
+          left_node.source_range.end.join(right_node.source_range.begin)
+        end
+
         def check_exploded(node)
           return correct_style_detected unless node.arguments.one?
 
@@ -121,13 +150,43 @@ module RuboCop
           return if allowed_non_exploded_type?(first_arg)
 
           add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
-            replacement = correction_compact_to_exploded(node)
+            correct_raise(node) { correct_to_exploded(corrector, node) }
+          end
+        end
 
-            corrector.replace(node, replacement)
-            opposite_style_detected
+        def correct_to_exploded(corrector, node)
+          if heredoc_new_argument?(node)
+            correct_heredoc_compact_to_exploded(corrector, node)
+          else
+            corrector.replace(node, correction_compact_to_exploded(node))
           end
         end
 
+        def heredoc_new_argument?(node)
+          new_call = node.first_argument
+          return false unless new_call.arguments.one? && heredoc?(new_call.first_argument)
+
+          node.parenthesized? || !parenthesize?(node)
+        end
+
+        def correct_heredoc_compact_to_exploded(corrector, node)
+          new_call = node.first_argument
+          corrector.replace(range_between(new_call.receiver, new_call.first_argument), ', ')
+          corrector.remove(new_call.loc.end) if new_call.loc.end
+        end
+
+        def correct_raise(node)
+          opposite_style_detected
+          return if inside_corrected_raise?(node)
+
+          yield
+          ignore_node(node)
+        end
+
+        def inside_corrected_raise?(node)
+          node.each_ancestor(:send).any? { |ancestor| ignored_node?(ancestor) }
+        end
+
         def use_new_method?(first_arg)
           first_arg.send_type? && first_arg.receiver && first_arg.method?(:new)
         end
@@ -151,8 +210,18 @@ module RuboCop
           Array(cop_config['AllowedCompactTypes']).include?(type)
         end
 
+        def parenthesize?(node)
+          return true if node.parenthesized?
+
+          node.parent && requires_parens?(node.parent)
+        end
+
         def requires_parens?(parent)
-          parent.operator_keyword? || (parent.if_type? && parent.ternary?)
+          return true if parent.operator_keyword?
+          return true if parent.type?(:call, :super, :yield, :array, :pair)
+          return true if parent.any_def_type? && parent.endless?
+
+          parent.if_type? && parent.ternary?
         end
       end
     end

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

@@ -100,6 +100,7 @@ module RuboCop
           return unless key
           return if accumulator_used_in_expressions?(block_node, key, value)
           return if nested_match?(key) || nested_match?(value)
+          return if heredoc_in_inject_numblock?(block_node, key, value)
 
           register_offense(node, block_node, key, value)
         end
@@ -124,6 +125,12 @@ module RuboCop
           end
         end
 
+        def heredoc_in_inject_numblock?(block_node, key, value)
+          return false if !block_node.numblock_type? || block_node.method?(:each_with_object)
+
+          [key, value].any? { |node| node.each_node(:any_str).any?(&:heredoc?) }
+        end
+
         def accumulator_name(block_node)
           index = block_node.method?(:each_with_object) ? 1 : 0
           block_node.argument_list[index].name
@@ -136,42 +143,20 @@ module RuboCop
         def register_offense(send_node, block_node, key_expr, value_expr)
           message = format(MSG, method: send_node.method_name)
 
+          # Each part is replaced separately so that heredoc bodies between them are kept.
           add_offense(send_node.loc.selector, message: message) do |corrector|
-            corrector.replace(
-              replacement_range(send_node, block_node),
-              replacement(block_node, key_expr, value_expr)
-            )
-          end
-        end
-
-        def replacement(block_node, key_expr, value_expr)
-          key_source = adjusted_source(key_expr, block_node)
-          value_source = adjusted_source(value_expr, block_node)
-          body = "[#{key_source}, #{value_source}]"
+            corrector.replace(method_call_range(send_node), 'to_h')
 
-          if block_node.numblock_type?
-            block_node.braces? ? "to_h { #{body} }" : do_end_replacement(block_node, body)
-          else
-            named_block_replacement(block_node, body)
-          end
-        end
+            unless block_node.numblock_type?
+              corrector.replace(block_node.arguments, "|#{element_arg_source(block_node)}|")
+            end
 
-        def named_block_replacement(block_node, body)
-          arg = element_arg_source(block_node)
-          if block_node.braces?
-            "to_h { |#{arg}| #{body} }"
-          else
-            do_end_replacement(block_node, body, arg)
+            correct_body(corrector, block_node, key_expr, value_expr)
           end
         end
 
-        def do_end_replacement(block_node, body, arg = nil)
-          args = arg ? " |#{arg}|" : ''
-          "to_h do#{args}\n#{indent(block_node)}  #{body}\n#{indent(block_node)}end"
-        end
-
-        def replacement_range(send_node, block_node)
-          range_between(send_node.loc.selector.begin_pos, block_node.source_range.end_pos)
+        def method_call_range(send_node)
+          range_between(send_node.loc.selector.begin_pos, send_node.source_range.end_pos)
         end
 
         def element_arg_source(block_node)
@@ -182,8 +167,18 @@ module RuboCop
           end
         end
 
+        def correct_body(corrector, block_node, key_expr, value_expr)
+          key_source = adjusted_source(key_expr, block_node)
+          value_source = adjusted_source(value_expr, block_node)
+          body = block_node.body
+          assignment = body.begin_type? ? body.children.first : body
+
+          corrector.replace(assignment, "[#{key_source}, #{value_source}]")
+          corrector.remove(accumulator_range(body.children.last)) if body.begin_type?
+        end
+
         def adjusted_source(expr_node, block_node)
-          source = expr_node.source
+          source = element_source(expr_node)
           return source unless block_node.numblock_type?
           return source if block_node.method?(:each_with_object)
 
@@ -191,8 +186,27 @@ module RuboCop
           source.gsub('_2', '_1')
         end
 
-        def indent(node)
-          ' ' * node.source_range.column
+        def element_source(expr_node)
+          if command_call?(expr_node) || expr_node.assignment? || expr_node.rescue_type?
+            return "(#{expr_node.source})"
+          end
+          return "[#{expr_node.source}]" if expr_node.array_type? && !expr_node.bracketed?
+
+          expr_node.source
+        end
+
+        def command_call?(node)
+          node = node.send_node if node.any_block_type?
+          return false unless node.type?(:call, :super, :yield)
+
+          node.arguments? && !node.parenthesized? && !node.operator_method? && !node.setter_method?
+        end
+
+        def accumulator_range(accumulator)
+          range = range_with_surrounding_space(accumulator.source_range, side: :left)
+          return range unless range.source_buffer.source[range.begin_pos - 1] == ';'
+
+          range_with_surrounding_space(range.adjust(begin_pos: -1), side: :left, newlines: false)
         end
       end
     end

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

@@ -67,6 +67,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant `begin` block detected.'
+        SPACE_INSIDE_PARENS_STYLES = %w[space compact].freeze
 
         def self.autocorrect_incompatible_with
           [Style::BlockDelimiters]
@@ -132,14 +133,15 @@ module RuboCop
           empty_begin?(node) ||
             begin_block_has_multiline_statements?(node) ||
             contain_rescue_or_ensure?(node) ||
-            valid_context_using_only_begin?(node)
+            valid_context_using_only_begin?(node) ||
+            ternary_operand_requiring_begin?(node)
         end
 
         def register_offense(node)
           offense_range = node.loc.begin
 
           add_offense(offense_range) do |corrector|
-            if node.parent&.assignment?
+            if node.parent&.assignment? || node.parent&.type?(:return, :next, :break)
               replace_begin_with_statement(corrector, offense_range, node)
             else
               remove_begin(corrector, offense_range, node)
@@ -156,7 +158,7 @@ module RuboCop
           first_child = node.children.first
 
           source = first_child.source
-          source = "(#{source})" if first_child.if_type? && first_child.modifier_form?
+          source = "(#{source})" if low_precedence_statement?(first_child)
 
           corrector.replace(offense_range, source)
           corrector.remove(range_between(offense_range.end_pos, first_child.source_range.end_pos))
@@ -164,6 +166,13 @@ module RuboCop
           restore_removed_comments(corrector, offense_range, node, first_child)
         end
 
+        def low_precedence_statement?(node)
+          return node.modifier_form? if node.basic_conditional?
+          return node.prefix_not? if node.send_type?
+
+          node.operator_keyword? && node.semantic_operator?
+        end
+
         def remove_begin(corrector, offense_range, node)
           if node.parent.respond_to?(:endless?) && node.parent.endless?
             offense_range = range_with_surrounding_space(offense_range, newlines: true)
@@ -184,7 +193,8 @@ module RuboCop
         def use_modifier_form_after_multiline_begin_block?(node)
           return false unless (parent = node.parent)
 
-          node.multiline? && parent.if_type? && parent.modifier_form?
+          node.multiline? && parent.if_type? && parent.modifier_form? &&
+            !parent.condition.equal?(node)
         end
 
         def correct_modifier_form_after_multiline_begin_block(corrector, node)
@@ -221,14 +231,44 @@ module RuboCop
             parent&.send_type? || parent&.operator_keyword?
         end
 
+        def ternary_operand_requiring_begin?(node)
+          return false unless node.parent&.if_type? && node.parent.ternary?
+
+          !node.children.one? || low_precedence_statement?(node.children.first)
+        end
+
         def valid_begin_assignment?(node)
-          node.parent&.assignment? && !node.children.one?
+          node.parent&.assignment? && (!node.children.one? || too_long_when_joined?(node))
+        end
+
+        def too_long_when_joined?(node)
+          statement = node.children.first
+          max = config.for_enabled_cop('Layout/LineLength')['Max']
+          return false unless max && statement.single_line?
+
+          length = statement.source.length
+          length += parentheses_width if low_precedence_statement?(statement)
+
+          node.loc.column + length > max
+        end
+
+        def parentheses_width
+          space_inside_parens? ? 4 : 2
+        end
+
+        def space_inside_parens?
+          return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+          style = config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle']
+
+          SPACE_INSIDE_PARENS_STYLES.include?(style)
         end
 
         def inspect_branches(node)
           node.branches.each do |branch|
             next unless branch&.kwbegin_type?
             next if branch.rescue_node || branch.ensure_node
+            next if ternary_operand_requiring_begin?(branch)
 
             register_offense(branch)
           end

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

@@ -78,7 +78,10 @@ module RuboCop
         ].freeze
 
         def on_if(node)
-          return if node.modifier_form? || node.elsif_conditional? || !offense?(node)
+          return unless redundant_condition_offense?(node)
+          return if node.each_ancestor(:if).any? do |ancestor|
+            redundant_condition_offense?(ancestor)
+          end
 
           message = message(node)
 
@@ -89,6 +92,10 @@ module RuboCop
 
         private
 
+        def redundant_condition_offense?(node)
+          !node.modifier_form? && !node.elsif_conditional? && offense?(node)
+        end
+
         def message(node)
           if redundant_condition?(node)
             REDUNDANT_CONDITION
@@ -240,10 +247,10 @@ module RuboCop
         end
 
         # rubocop:disable-next Metrics/AbcSize
-        def if_source(if_branch, arithmetic_operation)
+        def if_source(if_branch, binary_operator)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')
-          elsif arithmetic_operation
+          elsif binary_operator
             argument_source = if_branch.first_argument.source
 
             "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
@@ -257,8 +264,8 @@ module RuboCop
           end
         end
 
-        def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
-          if arithmetic_operation
+        def else_source(else_branch, binary_operator) # rubocop:disable Metrics/AbcSize
+          if binary_operator
             "#{else_branch.first_argument.source})"
           elsif branches_have_method?(else_branch.parent)
             else_source_if_has_method(else_branch)
@@ -295,11 +302,11 @@ module RuboCop
 
         def make_ternary_form(node)
           _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
-          arithmetic_operation = use_arithmetic_operation?(if_branch)
+          binary_operator = branches_have_method?(node) && binary_operator?(if_branch)
 
           ternary_form = [
-            if_source(if_branch, arithmetic_operation),
-            else_source(else_branch, arithmetic_operation)
+            if_source(if_branch, binary_operator),
+            else_source(else_branch, binary_operator)
           ].join(' || ')
           ternary_form += ')' if branches_have_method?(node) && if_branch.parenthesized?
 
@@ -320,17 +327,27 @@ module RuboCop
 
         def require_parentheses?(node)
           (node.basic_conditional? && node.modifier_form?) ||
-            node.range_type? ||
-            node.rescue_type? ||
-            (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
+            node.range_type? || node.rescue_type? ||
+            (node.respond_to?(:semantic_operator?) && node.semantic_operator?) ||
+            low_precedence_keyword?(node)
+        end
+
+        # e.g. `not foo`, `return foo`, and `yield foo`
+        def low_precedence_keyword?(node)
+          return node.prefix_not? if node.send_type?
+
+          node.type?(:return, :next, :break, :yield, :super) &&
+            node.arguments? && !node.parenthesized?
         end
 
         def require_braces?(node)
           node.hash_type? && !node.braces?
         end
 
-        def use_arithmetic_operation?(node)
-          node.respond_to?(:arithmetic_operation?) && node.arithmetic_operation?
+        # Any binary operator binds tighter than `||`, so the fallback must be
+        # parenthesized as its argument, e.g. `stack << (foo || :new)`.
+        def binary_operator?(node)
+          node.binary_operation? && !node.dot?
         end
 
         def without_argument_parentheses_method?(node)

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

@@ -25,6 +25,12 @@ module RuboCop
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
         MERGE_METHODS = %i[merge merge!].freeze
 
+        # `Style/TrailingCommaInHashLiteral` adds a comma to the hash literal whose braces
+        # this cop removes in the same pass, which would leave a dangling comma.
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInHashLiteral]
+        end
+
         # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
           return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)

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

@@ -37,23 +37,18 @@ module RuboCop
         private
 
         def fix_exploded(node)
-          exploded?(node) do |command, message|
+          exploded?(node) do |exception, message|
             # `raise RuntimeError, nil` uses the class name as the message, so
             # rewriting it to `raise nil.to_s` (an empty message) would change it.
             next if message.nil_type?
 
             add_offense(node, message: MSG_1) do |corrector|
-              corrector.replace(node, replaced_exploded(node, command, message))
+              corrector.remove(exception.source_range.join(message.source_range.begin))
+              corrector.replace(message, message_source(message))
             end
           end
         end
 
-        def replaced_exploded(node, command, message)
-          arg = string_message?(message) ? message.source : "#{message.source}.to_s"
-          arg = node.parenthesized? ? "(#{arg})" : " #{arg}"
-          "#{command}#{arg}"
-        end
-
         def string_message?(message)
           message.any_str_type?
         end
@@ -63,22 +58,43 @@ module RuboCop
             next if message.nil_type?
 
             add_offense(node, message: MSG_2) do |corrector|
-              corrector.replace(new_call, replaced_compact(message))
+              # Replacing the call would drop a heredoc body that sits inside its parentheses.
+              next if heredoc_body_inside?(new_call, message)
+
+              corrector.replace(new_call, message_source(message))
             end
           end
         end
 
-        def replaced_compact(message)
+        def heredoc_body_inside?(new_call, message)
+          message.each_node(:any_str).any? do |str|
+            str.heredoc? && str.loc.heredoc_end.end_pos < new_call.source_range.end_pos
+          end
+        end
+
+        def message_source(message)
           if string_message?(message)
             message.source
+          elsif require_parentheses?(message)
+            "(#{message.source}).to_s"
           else
             "#{message.source}.to_s"
           end
         end
 
+        def require_parentheses?(message)
+          if message.call_type?
+            !message.method?(:[]) &&
+              (message.operator_method? || (message.arguments? && !message.parenthesized?))
+          else
+            !(message.basic_literal? || message.variable? ||
+              message.type?(:const, :self, :begin, :array))
+          end
+        end
+
         # @!method exploded?(node)
         def_node_matcher :exploded?, <<~PATTERN
-          (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)
+          (send nil? {:raise :fail} $(const {nil? cbase} :RuntimeError) $_)
         PATTERN
 
         # @!method compact?(node)