rubocop 1.92.0 → 1.92.2

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

@@ -146,11 +146,26 @@ module RuboCop
         end
 
         def comment_before_to_f?(node)
+          return true if comment_around_fdiv_operator?(node)
+
           operands_losing_to_f(node).any? do |operand|
             next false unless to_f_method?(operand)
 
             range = operand.receiver.source_range.end.join(operand.loc.selector.begin)
-            processed_source.contains_comment?(range)
+            comment_in_range?(range)
+          end
+        end
+
+        def comment_around_fdiv_operator?(node)
+          return false unless style == :fdiv
+
+          range = node.receiver.source_range.end.join(node.first_argument.source_range.begin)
+          comment_in_range?(range)
+        end
+
+        def comment_in_range?(range)
+          processed_source.each_comment_in_lines(range.line..range.last_line).any? do |comment|
+            range.contains?(comment.source_range)
           end
         end
 

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

@@ -56,8 +56,10 @@ module RuboCop
 
         # `Style/RedundantBegin` removes the `begin` of a block body in the same pass,
         # leaving a `rescue` or `ensure` clause directly in the `for` body.
+        # `Style/ItBlockParameter` replaces block parameter references in the body
+        # with `it` in the same pass, while they become `for` loop variables.
         def self.autocorrect_incompatible_with
-          [Style::RedundantBegin]
+          [Style::RedundantBegin, Style::ItBlockParameter]
         end
 
         def on_for(node)
@@ -78,6 +80,7 @@ module RuboCop
 
           if style == :for
             return unless node.receiver
+            return unless convertible_to_for?(node)
             return if rescue_or_ensure_body?(node) || do_end_block_in_collection?(node)
 
             add_offense(node, message: PREFER_FOR) do |corrector|
@@ -123,6 +126,16 @@ module RuboCop
           node.multiline? && node.method?(:each) && !node.send_node.arguments?
         end
 
+        def convertible_to_for?(node)
+          return false if node.type?(:numblock, :itblock)
+          return true unless node.arguments?
+
+          arguments = node.arguments
+          return false if arguments.children.one? && arguments.children.first.restarg_type?
+
+          arguments.each_descendant.all? { |arg| arg.type?(:arg, :restarg, :mlhs) }
+        end
+
         def rescue_or_ensure_body?(node)
           node.body&.type?(:rescue, :ensure)
         end

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

@@ -186,40 +186,37 @@ module RuboCop
             return if trivial?(node)
 
             example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
-            replacement = <<~RUBY.chomp
-              #{conditional_keyword} #{condition.source}
-                #{scope_exiting_keyword}
-              end
-            RUBY
+            replacement = "#{conditional_keyword} #{condition.source}\n  #{scope_exiting_keyword}"
           end
 
           add_offense(node.loc.keyword, message: format(MSG, example: example)) do |corrector|
             next if node.else? && guard.nil?
 
-            autocorrect(corrector, node, condition, replacement || example, guard)
+            autocorrect(corrector, node, example, replacement, guard)
           end
         end
 
         # rubocop:disable-next Metrics/AbcSize
-        def autocorrect(corrector, node, condition, replacement, guard)
-          corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
-
-          if_branch = node.if_branch
-          else_branch = node.else_branch
-
+        def autocorrect(corrector, node, example, multiline_replacement, guard)
+          range = node.loc.keyword.join(node.condition.source_range)
+          corrector.replace(range, multiline_replacement || example)
           corrector.replace(node.loc.begin, "\n") if node.then?
 
-          if (if_heredoc = find_heredoc_argument(if_branch))
-            autocorrect_heredoc_argument(corrector, node, if_heredoc, else_branch, guard)
-          elsif (else_heredoc = find_heredoc_argument(else_branch))
-            autocorrect_heredoc_argument(corrector, node, else_heredoc, if_branch, guard)
-          else
-            corrector.remove(node.loc.end)
-            return unless node.else?
+          branches = [node.if_branch, node.else_branch]
+          guard_branch, leave_branch = guard == :else ? branches.reverse : branches
 
-            corrector.remove(node.loc.else)
-            corrector.remove(range_of_branch_to_remove(node, guard))
+          heredoc = find_heredoc_argument(guard_branch)
+          close_multiline_guard_clause(corrector, range, heredoc, guard) if multiline_replacement
+
+          if heredoc
+            return autocorrect_heredoc_argument(corrector, node, heredoc, leave_branch, guard)
           end
+
+          corrector.remove(node.loc.end)
+          return unless node.else?
+
+          corrector.remove(node.loc.else)
+          corrector.remove(range_of_branch_to_remove(node, guard))
         end
 
         def heredoc?(argument)
@@ -241,6 +238,10 @@ module RuboCop
           find_heredoc_argument(node.receiver)
         end
 
+        def close_multiline_guard_clause(corrector, range, heredoc, guard)
+          corrector.insert_after(guard && heredoc ? heredoc.loc.heredoc_end : range, "\nend")
+        end
+
         def autocorrect_heredoc_argument(corrector, node, heredoc_node, leave_branch, guard)
           remove_whole_lines(corrector, node.loc.end)
           return unless node.else?

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

@@ -44,6 +44,10 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Layout::MultilineArrayBraceLayout, Style::TrailingCommaInArrayLiteral]
+        end
+
         def on_hash(node)
           return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))

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

@@ -90,9 +90,19 @@ module RuboCop
         end
 
         def exempt_from_brackets?(node)
+          return true if forwarded_or_splatted?(node.first_argument)
+
           comment_before_dot?(node) || env_fetch_preferred?(node.receiver)
         end
 
+        def forwarded_or_splatted?(argument)
+          if argument.hash_type? && !argument.braces?
+            argument.children.any? { |child| child.type?(:kwsplat, :forwarded_kwrestarg) }
+          else
+            argument.type?(:forwarded_args, :forwarded_restarg, :splat, :block_pass)
+          end
+        end
+
         def comment_before_dot?(node)
           processed_source.contains_comment?(node.receiver.source_range.end.join(node.loc.dot))
         end

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

@@ -243,6 +243,7 @@ module RuboCop
 
         def self.autocorrect_incompatible_with
           [
+            Layout::HeredocArgumentClosingParenthesis,
             Style::NestedParenthesizedCalls,
             Style::RedundantParentheses,
             Style::RescueModifier,

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

@@ -169,12 +169,20 @@ module RuboCop
           location = node.arguments.source_range
 
           add_offense(location, message: MSG_MISSING) do |corrector|
-            add_parentheses(node.arguments, corrector)
+            corrector.replace(range_before_arguments(node), '(')
+            corrector.insert_after(location, ')')
 
             unexpected_style_detected 'require_no_parentheses'
           end
         end
 
+        def range_before_arguments(node)
+          range = node.loc.name.end.join(node.arguments.source_range.begin)
+          last_line_break = range.source.rindex("\n")
+
+          last_line_break ? range.resize(last_line_break) : range
+        end
+
         def unwanted_parentheses(args)
           add_offense(args, message: MSG_PRESENT) do |corrector|
             # offense is registered on args node when parentheses are unwanted

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

@@ -99,7 +99,10 @@ module RuboCop
 
           message = format(MSG, prefer: replacement, current: node.source)
           add_offense(node, message: message) do |corrector|
+            next if inside_corrected_predicate?(node)
+
             corrector.replace(node, replacement)
+            ignore_node(node)
           end
         end
 
@@ -115,6 +118,10 @@ module RuboCop
             BitwisePredicate.support_target_ruby_version?(target_ruby_version)
         end
 
+        def inside_corrected_predicate?(node)
+          node.each_ancestor(:send).any? { |ancestor| ignored_node?(ancestor) }
+        end
+
         def check(node)
           numeric, operator =
             if style == :predicate

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/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