rubocop 1.92.0 → 1.92.1

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

@@ -100,6 +100,7 @@ module RuboCop
                     pattern_matching_nodes(condition).any?
 
           return unless (msg = message(node))
+          return if modifier_sharing_line_in_logical_operator?(node)
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
             next if part_of_ignored_node?(node)
@@ -167,11 +168,11 @@ module RuboCop
             return to_modifier_form_with_move_comment(node, indent(node), comment)
           end
 
-          heredoc_ranges = heredoc_ranges_in(node.if_branch)
+          heredoc_ranges = heredoc_ranges_in(node)
           unless heredoc_ranges.empty?
             remove_heredoc(corrector, heredoc_ranges)
 
-            return to_normal_form_with_heredoc(node, indent(node), heredoc_ranges)
+            return to_normal_form_with_heredoc(node, indent(node))
           end
 
           to_normal_form(node, indent(node))
@@ -233,11 +234,18 @@ module RuboCop
         end
 
         def collection_from_ancestor(node)
-          return node if node&.type?(:array, :call)
+          return node if node&.type?(:array, :call, :and, :or)
 
           node.parent if node&.type?(:pair)
         end
 
+        def modifier_sharing_line_in_logical_operator?(node)
+          collection = find_containing_collection(node)
+          return false if !node.modifier_form? || !collection&.operator_keyword?
+
+          another_modifier_if_on_same_line?(node)
+        end
+
         def another_modifier_if_on_same_line?(node)
           collection = find_containing_collection(node)
           return false unless collection
@@ -280,15 +288,14 @@ module RuboCop
           end
         end
 
-        def to_normal_form_with_heredoc(node, indentation, heredoc_ranges)
-          heredoc_lines = heredoc_ranges.map(&:source)
-
-          <<~RUBY.chomp
-            #{node.keyword} #{node.condition.source}
-            #{indentation}  #{node.body.source}
-            #{heredoc_lines.join("\n")}
-            #{indentation}end
-          RUBY
+        def to_normal_form_with_heredoc(node, indentation)
+          [
+            "#{node.keyword} #{node.condition.source}",
+            *heredoc_ranges_in(node.condition).map(&:source),
+            "#{indentation}  #{node.body.source}",
+            *heredoc_ranges_in(node.if_branch).map(&:source),
+            "#{indentation}end"
+          ].join("\n")
         end
 
         def to_modifier_form_with_move_comment(node, indentation, comment)

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

@@ -59,6 +59,8 @@ module RuboCop
         MSG_AVOID_IT_PARAMETER = 'Avoid using `it` block parameter.'
         MSG_AVOID_IT_PARAMETER_MULTILINE = 'Avoid using `it` block parameter for multi-line blocks.'
 
+        SCOPE_TYPES = %i[any_def class module sclass].freeze
+
         minimum_target_ruby_version 3.4
 
         # `Style/StabbyLambdaParentheses` wraps the parameter this cop removes in the same pass,
@@ -67,6 +69,10 @@ module RuboCop
           [Style::Lambda, Style::StabbyLambdaParentheses]
         end
 
+        def on_new_investigation
+          @it_variable_definitions = nil
+        end
+
         def on_block(node)
           return unless style == :always
           return unless node.arguments.one?
@@ -75,7 +81,7 @@ module RuboCop
           return unless node.first_argument.arg_type?
 
           block_argument_name = node.first_argument.source
-          return if used_within_inner_block?(node.body, block_argument_name)
+          return if keep_parameter_name?(node.body, block_argument_name)
 
           find_block_variables(node, block_argument_name).each do |variable|
             add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
@@ -116,7 +122,7 @@ module RuboCop
         private
 
         def find_block_variables(node, block_argument_name)
-          return [] unless node.body
+          return [] if !node.body || it_variable_in_scope?(node)
 
           ranges = inner_block_ranges(node.body)
 
@@ -125,10 +131,47 @@ module RuboCop
           end
         end
 
+        def it_variable_in_scope?(node)
+          scope = nearest_scope(node)
+          return true if it_argument_in_scope?(node, scope)
+
+          it_variable_definitions.any? do |definition|
+            nearest_scope(definition).equal?(scope) && visible_in_block?(definition, node)
+          end
+        end
+
+        def it_variable_definitions
+          @it_variable_definitions ||=
+            variable_definitions(processed_source.ast).filter_map do |name, definition|
+              definition if name == 'it'
+            end
+        end
+
+        def nearest_scope(node)
+          node.each_ancestor(*SCOPE_TYPES).first
+        end
+
+        def it_argument_in_scope?(node, scope)
+          owners = node.each_ancestor(:block).select { |block| nearest_scope(block).equal?(scope) }
+          owners << scope if scope&.any_def_type?
+
+          owners.any? { |owner| owner.arguments.argument_list.any? { |arg| arg.name == :it } }
+        end
+
+        def visible_in_block?(definition, node)
+          return true if definition.source_range.begin_pos < node.source_range.begin_pos
+
+          node.source_range.contains?(definition.source_range)
+        end
+
         def inner_block_ranges(body)
           body.each_node(:any_block).map { |block| block.loc.begin.join(block.loc.end) }
         end
 
+        def keep_parameter_name?(body, block_arg_name)
+          used_within_inner_block?(body, block_arg_name) || reassigned?(body, block_arg_name)
+        end
+
         def used_within_inner_block?(body, block_argument_name)
           return false unless body
 
@@ -139,11 +182,29 @@ module RuboCop
           end
         end
 
+        def reassigned?(body, block_argument_name)
+          return false unless body
+
+          variable_definitions(body).any? { |name, _definition| name == block_argument_name }
+        end
+
         def block_variables(body, block_argument_name)
           body.each_descendant(:lvar).select do |descendant|
             descendant.source == block_argument_name
           end
         end
+
+        def variable_definitions(node)
+          node.each_node(:lvasgn, :match_var, :match_with_lvasgn).flat_map do |definition|
+            names = if definition.match_with_lvasgn_type?
+                      definition.children.first.each_capture(named: true).map(&:name)
+                    else
+                      [definition.children.first.to_s]
+                    end
+
+            names.map { |name| [name, definition] }
+          end
+        end
       end
     end
   end

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

@@ -129,12 +129,27 @@ module RuboCop
 
           return unless node.arguments?
 
-          arg_str = "(#{lambda_arg_string(node.arguments)})"
+          arg_str = lambda_arg_string(node.arguments)
+          arg_str = " #{arg_str} " if space_inside_parens?
+          arg_str = "(#{arg_str})"
+          arg_str = " #{arg_str}" if space_in_lambda_literal_required?
 
           corrector.insert_after(node.send_node, arg_str)
           corrector.remove(arguments_with_whitespace(node))
         end
 
+        def space_inside_parens?
+          return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+          %w[space compact].include?(config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle'])
+        end
+
+        def space_in_lambda_literal_required?
+          return false unless config.cop_enabled?('Layout/SpaceInLambdaLiteral')
+
+          config.for_cop('Layout/SpaceInLambdaLiteral')['EnforcedStyle'] == 'require_space'
+        end
+
         def arguments_with_whitespace(node)
           node.loc.begin.end.join(node.arguments.loc.end)
         end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -30,7 +30,7 @@ module RuboCop
 
           private
 
-          def omit_parentheses(node) # rubocop:disable Metrics/PerceivedComplexity
+          def omit_parentheses(node) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
             return if require_parentheses_for_hash_value_omission?(node)
@@ -42,6 +42,7 @@ module RuboCop
             return if allowed_string_interpolation_method_call?(node)
             return if code_after_closing_parenthesis_on_its_own_line?(node)
             return if comment_before_first_argument?(node)
+            return if args_parenthesized?(node)
 
             (@pending_omit_offenses ||= []) << node
           end
@@ -132,7 +133,7 @@ module RuboCop
             opening.source_line[(opening.column + 1)..].gsub(TRAILING_WHITESPACE_REGEX, '').empty?
           end
 
-          def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
+          def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
             call_in_literals?(node) ||
               node.parent&.when_type? ||
               call_with_ambiguous_arguments?(node) ||
@@ -142,7 +143,9 @@ module RuboCop
               allowed_multiline_call_with_parentheses?(node) ||
               allowed_chained_call_with_parentheses?(node) ||
               assignment_in_condition?(node) ||
-              forwards_anonymous_rest_arguments?(node)
+              command_assignment_in_expression?(node) ||
+              forwards_anonymous_rest_arguments?(node) ||
+              trailing_comma?(node)
           end
 
           def call_in_literals?(node)
@@ -278,7 +281,7 @@ module RuboCop
           end
 
           def assigned_before?(node, target)
-            node.assignment? && node.loc.operator.begin < target.loc.begin
+            node.assignment? && node.loc.operator.begin < target.source_range.begin
           end
 
           def inside_string_interpolation?(node)
@@ -295,6 +298,27 @@ module RuboCop
             parent.assignment? && (grandparent.conditional? || grandparent.when_type?)
           end
 
+          # rubocop:disable-next Metrics/PerceivedComplexity
+          def command_assignment_in_expression?(node)
+            value = node.parent&.type?(:any_block, :rescue) ? node.parent : node
+            assignment = outermost_assignment(value)
+            return false if assignment.equal?(value)
+
+            call_in_literals?(assignment) ||
+              call_in_logical_operators?(assignment) ||
+              call_in_optional_arguments?(assignment) ||
+              call_as_argument_or_chain?(assignment) ||
+              assignment.parent&.type?(:masgn, :return, :next, :break, :defined?)
+          end
+
+          def outermost_assignment(value)
+            parent = value.parent
+            return value if !parent&.assignment? || parent.masgn_type?
+            return value unless assigned_before?(parent, value)
+
+            outermost_assignment(parent)
+          end
+
           def forwards_anonymous_rest_arguments?(node)
             node.arguments.any? do |argument|
               next true if argument.forwarded_restarg_type?
@@ -302,6 +326,14 @@ module RuboCop
               argument.hash_type? && argument.children.any?(&:forwarded_kwrestarg_type?)
             end
           end
+
+          def trailing_comma?(node)
+            return false unless (last_argument = node.last_argument)
+
+            range = last_argument.source_range.end.join(node.loc.end.begin)
+
+            processed_source.tokens_within(range).any?(&:comma?)
+          end
         end
       end
     end

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

@@ -117,17 +117,26 @@ module RuboCop
 
         def separate_mixins(node)
           arguments = node.arguments.reverse
-          mixins = ["#{node.method_name} #{arguments.first.source}"]
+          mixins = [mixin_call(node.method_name, arguments.first.source, node.parenthesized?)]
 
           arguments[1..].inject(mixins) do |replacement, arg|
-            replacement << "#{indent(node)}#{node.method_name} #{arg.source}"
+            call = mixin_call(node.method_name, arg.source, node.parenthesized?)
+            replacement << "#{indent(node)}#{call}"
           end.join("\n")
         end
 
         def group_mixins(node, mixins)
           mixin_names = mixins.reverse.flat_map { |mixin| mixin.arguments.map(&:source) }
 
-          "#{node.method_name} #{mixin_names.join(', ')}"
+          mixin_call(node.method_name, mixin_names.join(', '), mixins.any?(&:parenthesized?))
+        end
+
+        def mixin_call(method_name, arguments_source, parenthesized)
+          if parenthesized
+            "#{method_name}(#{arguments_source})"
+          else
+            "#{method_name} #{arguments_source}"
+          end
         end
       end
     end

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

@@ -150,7 +150,7 @@ module RuboCop
         # is the last element and spans multiple lines, the trailing comma lands between the literal
         # and the `.freeze` appended in the same pass.
         def self.autocorrect_incompatible_with
-          [Style::TrailingCommaInArrayLiteral, Style::TrailingCommaInHashLiteral]
+          [Style::HashAsLastArrayItem, Style::TrailingCommaInArrayLiteral, Style::TrailingCommaInHashLiteral]
         end
 
         def on_casgn(node)
@@ -228,15 +228,32 @@ module RuboCop
             return
           end
 
+          return expand_omitted_hash_value(corrector, node.parent) if omitted_hash_value?(node)
+
+          wrap_for_freeze(corrector, node, expr)
+          corrector.insert_after(expr, '.freeze')
+
+          freeze_nested_literals(corrector, node) if recursive?
+        end
+
+        def omitted_hash_value?(node)
+          node.parent&.pair_type? && node.parent.value_omission?
+        end
+
+        def expand_omitted_hash_value(corrector, pair)
+          key = pair.key.value
+
+          corrector.replace(pair, "#{key}: #{key}.freeze")
+        end
+
+        def wrap_for_freeze(corrector, node, expr)
           if node.array_type? && !node.bracketed?
             corrector.wrap(expr, '[', ']')
+          elsif node.hash_type? && !node.braces?
+            corrector.wrap(expr, '{ ', ' }')
           elsif requires_parentheses?(node)
             corrector.wrap(expr, '(', ')')
           end
-
-          corrector.insert_after(expr, '.freeze')
-
-          freeze_nested_literals(corrector, node) if recursive?
         end
 
         # Recursively freezes every nested mutable literal inside an array or
@@ -262,13 +279,14 @@ module RuboCop
         # Returns the child literals of an array or hash node that may
         # themselves need freezing. For hashes, both keys and values are
         # included. Percent-literal arrays (e.g. `%w(a b)`) are skipped because
-        # `.freeze` cannot be appended to their contents.
+        # `.freeze` cannot be appended to their contents. Splat elements are
+        # skipped because the splatted object is not stored in the array.
         def literal_children(node)
           case node.type
           when :array
             return [] if node.percent_literal?
 
-            node.children
+            node.children.reject(&:splat_type?)
           when :hash
             node.children.flat_map { |child| child.pair_type? ? child.children : [] }
           else

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

@@ -83,7 +83,7 @@ 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 parens_allowed?(cond)
 
             message = message(cond)

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

@@ -101,10 +101,7 @@ module RuboCop
             return if exception.send_type? && exception.first_argument&.hash_type?
 
             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
+              replace_raise(corrector, node, correction_exploded_to_compact(node))
             end
           else
             correct_style_detected
@@ -121,13 +118,22 @@ 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)
-
-            corrector.replace(node, replacement)
-            opposite_style_detected
+            replace_raise(corrector, node, correction_compact_to_exploded(node))
           end
         end
 
+        def replace_raise(corrector, node, replacement)
+          opposite_style_detected
+          return if inside_corrected_raise?(node)
+
+          corrector.replace(node, replacement)
+          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
@@ -152,7 +158,11 @@ module RuboCop
         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/redundant_begin.rb

@@ -191,7 +191,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)

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

@@ -29,8 +29,7 @@ module RuboCop
                          operation_produces_immutable_object?(node.receiver))
 
           add_offense(node) do |corrector|
-            corrector.remove(node.loc.dot)
-            corrector.remove(node.loc.selector)
+            corrector.remove(node.loc.dot.join(node.loc.selector))
           end
         end
 

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

@@ -30,6 +30,10 @@ module RuboCop
 
         minimum_target_ruby_version 3.0
 
+        def self.autocorrect_incompatible_with
+          [Layout::MultilineMethodCallBraceLayout]
+        end
+
         # @!method redundant_unfreeze?(node)
         def_node_matcher :redundant_unfreeze?, <<~PATTERN
           {
@@ -41,9 +45,10 @@ module RuboCop
         def on_dstr(node)
           return if uninterpolated_string?(node) || uninterpolated_heredoc?(node)
           return unless redundant_unfreeze?(node.parent)
+          return if comment_outside_string?(node)
 
           add_offense(offense_range(node.parent)) do |corrector|
-            corrector.replace(node.parent, node.source)
+            remove_unfreeze(corrector, node.parent, node)
           end
         end
 
@@ -56,6 +61,24 @@ module RuboCop
             node.loc.selector
           end
         end
+
+        # Only the parts around the string are removed, so that an unfrozen string
+        # interpolated into it can be corrected in the same pass.
+        def remove_unfreeze(corrector, node, string)
+          corrector.remove(node.source_range.begin.join(string.source_range.begin))
+          corrector.remove(string.source_range.end.join(node.source_range.end))
+        end
+
+        def comment_outside_string?(node)
+          call_range = node.parent.source_range
+          string_range = node.source_range
+
+          processed_source.comments.any? do |comment|
+            range = comment.source_range
+
+            call_range.contains?(range) && !string_range.contains?(range)
+          end
+        end
       end
     end
   end

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

@@ -23,14 +23,20 @@ module RuboCop
       #   foo = bar unless condition
       #
       class RedundantSelfAssignmentBranch < Base
+        include RescueNode
         extend AutoCorrector
 
         MSG = 'Remove the self-assignment branch.'
 
+        STATEMENT_BODY_TYPES = %i[
+          kwbegin def defs block numblock itblock class module sclass rescue ensure
+        ].freeze
+
         def on_lvasgn(node)
           expression = node.expression
 
           return unless use_if_and_else_branch?(expression)
+          return unless statement?(node)
 
           if_branch = expression.if_branch
           else_branch = expression.else_branch
@@ -51,6 +57,28 @@ module RuboCop
           !expression.ternary? || !expression.else?
         end
 
+        def statement?(node)
+          parent = node.parent
+          return true if parent.nil? || parent.type?(*STATEMENT_BODY_TYPES)
+          return parent.loc.begin.nil? if parent.begin_type?
+          return !rescue_modifier?(parent) if parent.resbody_type?
+
+          statement_branch?(node, parent)
+        end
+
+        def statement_branch?(node, parent)
+          case parent.type
+          when :if
+            !parent.ternary? && !node.equal?(parent.condition)
+          when :when, :in_pattern, :while, :until, :for
+            node.equal?(parent.body)
+          when :case, :case_match
+            node.equal?(parent.else_branch)
+          else
+            false
+          end
+        end
+
         def inconvertible_to_modifier?(if_branch, else_branch)
           multiple_statements?(if_branch) || multiple_statements?(else_branch) ||
             (else_branch.respond_to?(:elsif?) && else_branch.elsif?)

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

@@ -123,12 +123,29 @@ module RuboCop
         end
 
         def register_offense(node, sort_node, sorter, accessor)
+          return if code_after_accessor_kept_apart?(node)
+
           message = message(node, sorter, accessor)
           add_offense(offense_range(sort_node, node), message: message) do |corrector|
             autocorrect(corrector, node, sort_node, sorter, accessor)
           end
         end
 
+        def code_after_accessor_kept_apart?(node)
+          return false if with_logical_operator?(node)
+
+          source = before_accessor_source(node)
+          return false if !source.include?("\n") || source.strip.empty?
+
+          rest = code_after_accessor(node)
+
+          !rest.empty? && !rest.match?(/\A(#|&?\.|[)\]},])/)
+        end
+
+        def code_after_accessor(node)
+          processed_source.lines[node.last_line - 1][node.source_range.last_column..].strip
+        end
+
         def offense_range(sort_node, node)
           range_between(sort_node.loc.selector.begin_pos, node.source_range.end_pos)
         end
@@ -146,12 +163,29 @@ module RuboCop
         end
 
         def autocorrect(corrector, node, sort_node, sorter, accessor)
-          # Remove accessor, e.g. `first` or `[-1]`.
-          corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
           # Replace "sort" or "sort_by" with the appropriate min/max method.
           corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
-          # Replace to avoid syntax errors when followed by a logical operator.
-          replace_with_logical_operator(corrector, node) if with_logical_operator?(node)
+          remove_accessor(corrector, node)
+        end
+
+        def remove_accessor(corrector, node)
+          if removable_line_break_before_accessor?(node)
+            corrector.remove(node.receiver.source_range.end.join(node.source_range.end))
+          else
+            corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
+
+            replace_with_logical_operator(corrector, node) if with_logical_operator?(node)
+          end
+        end
+
+        def removable_line_break_before_accessor?(node)
+          source = before_accessor_source(node)
+
+          source.include?("\n") && source.strip.empty?
+        end
+
+        def before_accessor_source(node)
+          node.receiver.source_range.end.join((node.loc.dot || node.loc.selector).begin).source
         end
 
         def replace_with_logical_operator(corrector, node)