rubocop 1.92.0 → 1.92.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82ffd9b6c03e12d770357a074e5f04f30536c85ce4afb9eff74987f03951d756
-  data.tar.gz: f9032e319d69366079bd51472893ef0e780e8405b2d3892ccde21c23deaf3fe0
+  metadata.gz: 2e582386de45680cecfa5173359f6ccb24894b2440ef9d6fec5ec5c0d28d0b41
+  data.tar.gz: ef3bdbb7e39a1960f5e1feb41df80f7afef2f35148a44693566f725b99715a3a
 SHA512:
-  metadata.gz: c00f0dac21282c6d8727c74ef585bab1d21f2818e29003b99e05d740ab2a142160d8cbfc9030e0654dbc6d08f83e811333d02bf41d4ea7bca3a033f03783efcc
-  data.tar.gz: 88f197ff630a6531ac0f702c46f68ccbe3d78315aa3f4ec57d0155b854d421bd0ef0abed6dcc7835cd90a869da14909ca99c606dd8d463a641c901a223dc6092
+  metadata.gz: dff3c8ee84b5334d4aabb751f7de89b2cf2b87d65ad7970913132f558909d80da6306f60707f0ba1001d826a22c3491d9ab716c82defb20bb10216654cf75902
+  data.tar.gz: 6c6913ed8f1d4f30ee0044df54c2c370aa59b2f1f91de340f33295af795fcd56138b75583c37049c3fd117ffd51241600bd24e0c5e82d41b58304821a8170a25

data/config/default.yml

@@ -3943,6 +3943,7 @@ Style/CollectionQuerying:
   StyleGuide: '#collection-querying'
   Enabled: pending
   VersionAdded: '1.77'
+  VersionChanged: '1.92'
   Safe: false
 
 Style/ColonMethodCall:

data/lib/rubocop/config.rb

@@ -56,10 +56,6 @@ module RuboCop
             deprecated_config = @for_cop[deprecated_cop_name]
             next if deprecated_config.empty?
 
-            warn Rainbow(<<~WARNING).yellow
-              Warning: Using `#{deprecated_cop_name}` configuration in #{loaded_path} for `#{cop}`.
-            WARNING
-
             cop_options.merge!(@for_cop[deprecated_cop_name])
           end
         end

data/lib/rubocop/config_obsoletion.rb

@@ -76,6 +76,15 @@ module RuboCop
       raise ValidationError, messages.join("\n")
     end
 
+    # Messages for every violated rule, regardless of severity, without raising.
+    # Used for configuration the user does not own (a plugin's defaults), where an
+    # obsolete key should be reported but must not stop the run. Extracted cops are
+    # left out: whether their gem is loaded is only known once every plugin has been
+    # integrated, and this is called while plugins are still loading.
+    def messages
+      rules.grep_v(ExtractedCop).select(&:violated?).map(&:message)
+    end
+
     def legacy_cop_names
       # Used by DepartmentName#qualified_legacy_cop_name
       cop_rules.map(&:old_name)

data/lib/rubocop/cop/badge.rb

@@ -39,7 +39,7 @@ module RuboCop
       end
 
       def ==(other)
-        hash == other.hash
+        other.is_a?(Badge) && department == other.department && cop_name == other.cop_name
       end
       alias eql? ==
 

data/lib/rubocop/cop/correctors/each_to_for_corrector.rb

@@ -29,7 +29,7 @@ module RuboCop
                     format(
                       CORRECTION_WITH_ARGUMENTS,
                       collection: collection_node.source,
-                      variables: argument_node.children.map(&:source).join(', ')
+                      variables: loop_variables
                     )
                   else
                     format(CORRECTION_WITHOUT_ARGUMENTS, enumerable: collection_node.source)
@@ -38,6 +38,21 @@ module RuboCop
         padding_needed?(offending_range.end_pos) ? "#{keyword} " : keyword
       end
 
+      def loop_variables
+        variables = argument_node.children.map { |argument| loop_variable(argument) }.join(', ')
+
+        argument_node.source.match?(/,\s*\|\z/) ? "#{variables}," : variables
+      end
+
+      def loop_variable(argument)
+        return argument.source unless argument.mlhs_type?
+
+        variables = argument.children.map { |child| loop_variable(child) }.join(', ')
+        lone_target = argument.children.one? && !argument.children.first.restarg_type?
+
+        lone_target ? "(#{variables},)" : "(#{variables})"
+      end
+
       def closing_keyword
         padding_needed?(block_node.loc.end.begin_pos - 1) ? ' end' : 'end'
       end

data/lib/rubocop/cop/correctors/empty_line_corrector.rb

@@ -12,7 +12,7 @@ module RuboCop
           when :no_empty_lines
             corrector.remove(range)
           when :empty_lines
-            corrector.insert_before(range.begin, "\n")
+            corrector.replace(range.begin.adjust(begin_pos: -1), "\n\n")
           end
         end
 

data/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb

@@ -76,8 +76,8 @@ module RuboCop
       end
 
       def remove_trailing_whitespace(corrector)
-        size = block_begin.begin_pos - arguments.source_range.end_pos - 1
-        corrector.remove_preceding(block_begin, size) if size.positive?
+        whitespace = arguments.source_range.end.join(block_begin.begin)
+        corrector.replace(whitespace, ' ') if whitespace.size > 1
       end
 
       def replace_delimiters(corrector)

data/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb

@@ -27,6 +27,7 @@ module RuboCop
           # corrected. The user must handle the delicate decision of where to
           # put the comment.
           return if new_line_needed_before_closing_brace?(node)
+          return if nested_closing_bracket_moved_before_comment?
 
           end_range = last_element_range_with_trailing_comma(node).end
 
@@ -43,6 +44,39 @@ module RuboCop
         corrector.insert_before(node.loc.end, "\n")
       end
 
+      def nested_closing_bracket_moved_before_comment?
+        last_element = children(node).last
+        return false unless (comment = processed_source.comment_at_line(last_element.last_line - 1))
+        return false unless (nested = nested_literal_with_closing_bracket_on_own_line(last_element))
+
+        own_line_comment?(comment) || !(nested.chained? || nested.argument?)
+      end
+
+      def nested_literal_with_closing_bracket_on_own_line(last_element)
+        last_line = last_element.last_line
+
+        last_element.each_node.find do |descendant|
+          same_kind_as_node?(descendant) && closing_bracket_on_own_line?(descendant, last_line)
+        end
+      end
+
+      def same_kind_as_node?(descendant)
+        descendant.type == node.type || (descendant.call_type? && node.call_type?)
+      end
+
+      def closing_bracket_on_own_line?(descendant, line)
+        return false unless descendant.loc?(:end) && descendant.loc.end.is?('}', ']', ')')
+
+        closing_bracket = descendant.loc.end
+        return false if closing_bracket.line != line
+
+        closing_bracket.source_line[0...closing_bracket.column].strip.empty?
+      end
+
+      def own_line_comment?(comment)
+        comment.source_range.source_line.lstrip.start_with?('#')
+      end
+
       def correct_next_line_brace(corrector, end_range)
         corrector.remove(range_with_surrounding_space(node.loc.end, side: :left))
         corrector.insert_before(end_range, content_if_comment_present(corrector, node))

data/lib/rubocop/cop/layout/argument_alignment.rb

@@ -53,7 +53,7 @@ module RuboCop
 
         def on_send(node)
           return if !multiple_arguments?(node) || (node.call_type? && node.method?(:[]=)) ||
-                    autocorrect_incompatible_with_other_cops?
+                    binary_operator_call?(node) || autocorrect_incompatible_with_other_cops?
 
           items = flattened_arguments(node)
 
@@ -64,6 +64,10 @@ module RuboCop
 
         private
 
+        def binary_operator_call?(node)
+          node.binary_operation? && !node.method?(:[]) && !node.loc.dot
+        end
+
         def autocorrect_incompatible_with_other_cops?
           with_first_argument_style? && enforce_hash_argument_with_separator?
         end

data/lib/rubocop/cop/layout/class_structure.rb

@@ -341,9 +341,26 @@ module RuboCop
 
             return "#{node_visibility(node)}_methods"
           end
+          return class_method_category(node) if node.defs_type?
+
           HUMANIZED_NODE_TYPE[node.type] || node.type
         end
 
+        # Only `private_class_method` reaches a singleton method; a bare `private` does not.
+        # Such a call follows the definition it names, so only right siblings are searched.
+        def class_method_category(node)
+          modifier = node.right_siblings.reverse.find do |sibling|
+            class_method_visibility_modifier?(sibling, method_name: node.method_name)
+          end
+
+          modifier ? :"#{modifier.method_name}s" : HUMANIZED_NODE_TYPE[node.type]
+        end
+
+        # @!method class_method_visibility_modifier?(node, method_name:)
+        def_node_matcher :class_method_visibility_modifier?, <<~PATTERN
+          (send nil? {:private_class_method :public_class_method} <(sym %method_name) ...>)
+        PATTERN
+
         def dynamic_constant?(node)
           return false unless node.casgn_type? && node.namespace.nil?
 
@@ -429,12 +446,9 @@ module RuboCop
         end
 
         def end_position_for(node)
-          if node.casgn_type?
-            heredoc = find_heredoc(node)
-            return heredoc.location.heredoc_end.end_pos if heredoc
-          end
+          heredoc_end_lines = heredocs(node).map { |heredoc| heredoc.loc.heredoc_end.line }
+          end_line = [node.last_line, *heredoc_end_lines].max
 
-          end_line = buffer.line_for_position(node.source_range.end_pos)
           buffer.line_range(end_line).end_pos
         end
 
@@ -457,8 +471,8 @@ module RuboCop
           buffer.line_range(node.loc.line).begin_pos - 1
         end
 
-        def find_heredoc(node)
-          node.each_node(:any_str).find(&:heredoc?)
+        def heredocs(node)
+          node.each_node(:any_str).select(&:heredoc?)
         end
 
         def buffer

data/lib/rubocop/cop/layout/dot_position.rb

@@ -27,10 +27,6 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def self.autocorrect_incompatible_with
-          [Style::RedundantSelf]
-        end
-
         def on_send(node)
           return unless node.dot? || node.safe_navigation?
 
@@ -46,21 +42,35 @@ module RuboCop
 
         private
 
+        # The dot and the gap it moves across are replaced in one action, so that another
+        # correction that rewrites a range spanning the dot clashes with this one instead of
+        # leaving the moved dot behind.
         def autocorrect(corrector, dot, node)
-          dot_range = if processed_source[dot.line - 1].strip == '.'
-                        range_by_whole_lines(dot, include_final_newline: true)
-                      else
-                        dot
-                      end
-          corrector.remove(dot_range)
-          case style
-          when :leading
-            corrector.insert_before(selector_range(node), dot.source)
-          when :trailing
-            corrector.insert_after(node.receiver, dot.source)
+          dot_range = removed_dot_range(dot)
+
+          if style == :leading
+            move_dot_before_selector(corrector, dot, dot_range, selector_range(node))
+          else
+            move_dot_after_receiver(corrector, dot, dot_range, node.receiver)
           end
         end
 
+        def removed_dot_range(dot)
+          return dot unless processed_source[dot.line - 1].strip == '.'
+
+          range_by_whole_lines(dot, include_final_newline: true)
+        end
+
+        def move_dot_before_selector(corrector, dot, dot_range, selector)
+          gap = range_between(dot_range.end_pos, selector.begin_pos)
+          corrector.replace(dot_range.join(gap), "#{gap.source}#{dot.source}")
+        end
+
+        def move_dot_after_receiver(corrector, dot, dot_range, receiver)
+          gap = range_between(receiver.source_range.end_pos, dot_range.begin_pos)
+          corrector.replace(gap.join(dot_range), "#{dot.source}#{gap.source}")
+        end
+
         def message(dot)
           "Place the #{dot.source} on the " +
             case style

data/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb

@@ -61,23 +61,23 @@ module RuboCop
           return if node.ternary?
 
           if node.modifier_form?
-            check_condition(node.condition) if node.right_sibling
+            check_condition(node.condition, node.right_sibling) if followed_by_statement?(node)
           else
             check_condition(node.condition, node.if_branch)
           end
         end
 
         def on_while(node)
-          return if node.modifier_form? && !node.right_sibling
+          return if node.modifier_form? && !followed_by_statement?(node)
 
-          check_condition(node.condition, node.modifier_form? ? nil : node.body)
+          check_condition(node.condition, node.modifier_form? ? node.right_sibling : node.body)
         end
         alias on_until on_while
 
         def on_while_post(node)
-          return unless node.right_sibling
+          return unless followed_by_statement?(node)
 
-          check_condition(node.condition)
+          check_condition(node.condition, node.right_sibling)
         end
         alias on_until_post on_while_post
 
@@ -106,10 +106,14 @@ module RuboCop
 
         private
 
-        def check_condition(condition, body = nil)
+        def followed_by_statement?(node)
+          node.parent&.type?(:begin, :kwbegin) && node.right_sibling
+        end
+
+        def check_condition(condition, following_node)
           return unless condition.multiline?
           return if next_line_empty?(condition.last_line)
-          return if body_on_line?(body, condition.last_line)
+          return if body_on_line?(following_node, condition.last_line)
 
           add_offense(condition, &autocorrect(condition))
         end

data/lib/rubocop/cop/layout/empty_lines_after_module_inclusion.rb

@@ -91,7 +91,7 @@ module RuboCop
         end
 
         def next_line_node(node)
-          return if node.parent.type?(:if, :rescue, :ensure)
+          return if node.parent.type?(:if, :rescue, :ensure, :and, :or)
 
           node.right_sibling
         end

data/lib/rubocop/cop/layout/empty_lines_around_block_body.rb

@@ -38,13 +38,19 @@ module RuboCop
         KIND = 'block'
 
         def on_block(node)
-          first_line = node.loc.begin.line
-
-          check(node, node.body, adjusted_first_line: first_line)
+          check(node, node.body, adjusted_first_line: body_start_line(node))
         end
 
         alias on_numblock on_block
         alias on_itblock on_block
+
+        private
+
+        def body_start_line(node)
+          return node.loc.begin.line unless node.arguments?
+
+          [node.loc.begin.line, node.arguments.last_line].max
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/end_alignment.rb

@@ -80,10 +80,6 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def on_class(node)
-          check_other_alignment(node)
-        end
-
         def on_sclass(node)
           if node.parent&.assignment?
             check_asgn_alignment(node.parent, node)
@@ -91,10 +87,8 @@ module RuboCop
             check_other_alignment(node)
           end
         end
-
-        def on_module(node)
-          check_other_alignment(node)
-        end
+        alias on_class on_sclass
+        alias on_module on_sclass
 
         def on_if(node)
           check_other_alignment(node) unless node.ternary?
@@ -177,13 +171,7 @@ module RuboCop
           when :keyword
             node
           when :variable
-            align_to = alignment_node_for_variable_style(node)
-
-            while (parent = align_to.parent) && parent.send_type? && same_line?(align_to, parent)
-              align_to = parent
-            end
-
-            align_to
+            alignment_node_for_variable_style(node)
           else
             start_line_range(node)
           end
@@ -213,6 +201,8 @@ module RuboCop
               leading_node(extract_rhs(ancestor)).equal?(node)
             elsif ancestor.send_type? && ancestor.operator_method?
               !leading_node(ancestor).equal?(node)
+            elsif ancestor.send_type?
+              leading_node(ancestor.last_argument).equal?(node)
             end
           end
         end

data/lib/rubocop/cop/layout/extra_spacing.rb

@@ -30,6 +30,7 @@ module RuboCop
       #   some_object.method(arg)    # this is some comment
       class ExtraSpacing < Base
         extend AutoCorrector
+        include LineLengthHelp
         include PrecedingFollowingAlignment
         include RangeHelp
 
@@ -37,7 +38,7 @@ module RuboCop
         MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s assignment.'
 
         def self.autocorrect_incompatible_with
-          [Style::SelfAssignment]
+          [Layout::RedundantLineBreak, Style::SelfAssignment]
         end
 
         def on_new_investigation
@@ -77,9 +78,14 @@ module RuboCop
         def check_assignment(token)
           return unless aligned_with_preceding_equals_operator(token) == :no
 
+          tokens, align_to = equal_sign_alignment(token.line)
+          return if exceeds_max_line_length?(tokens, align_to)
+
           message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
           add_offense(token.pos, message: message) do |corrector|
-            align_equal_signs(token.pos, corrector)
+            tokens.each do |asgn_token|
+              align_equal_sign(corrector, asgn_token, align_to)
+            end
           end
         end
 
@@ -240,14 +246,19 @@ module RuboCop
           cop_config['ForceEqualSignAlignment']
         end
 
-        def align_equal_signs(range, corrector)
-          lines  = all_relevant_assignment_lines(range.line)
+        def equal_sign_alignment(line_number)
+          lines  = all_relevant_assignment_lines(line_number)
           tokens = assignment_tokens.select { |t| lines.include?(t.line) }
 
-          columns  = tokens.map { |t| align_column(t) }
-          align_to = columns.max
+          [tokens, tokens.map { |t| align_column(t) }.max]
+        end
 
-          tokens.each { |token| align_equal_sign(corrector, token, align_to) }
+        def exceeds_max_line_length?(tokens, align_to)
+          max_line_length && tokens.any? do |token|
+            padding = align_to - token.pos.last_column
+
+            padding.positive? && line_length(token.pos.source_line) + padding > max_line_length
+          end
         end
 
         def align_equal_sign(corrector, token, align_to)

data/lib/rubocop/cop/layout/first_argument_indentation.rb

@@ -152,6 +152,10 @@ module RuboCop
 
         MSG = 'Indent the first argument one step more than %<base>s.'
 
+        def self.autocorrect_incompatible_with
+          [Layout::ArgumentAlignment, Layout::HashAlignment]
+        end
+
         def on_send(node)
           return unless should_check?(node)
           return if same_line?(node, node.first_argument)
@@ -180,7 +184,13 @@ module RuboCop
 
           top_level_send = find_top_level_send(send_node)
           node_to_correct =
-            should_correct_entire_chain?(send_node, top_level_send) ? top_level_send : node
+            if should_correct_entire_chain?(send_node, top_level_send)
+              top_level_send
+            elsif hash_elements_aligned_by_argument_alignment?(node)
+              node.children.first
+            else
+              node
+            end
 
           AlignmentCorrector.correct(corrector, processed_source, node_to_correct, column_delta)
         end
@@ -210,6 +220,21 @@ module RuboCop
           top_level_send
         end
 
+        # `Layout/ArgumentAlignment` with `with_fixed_indentation` indents the pairs of an
+        # unbraced hash to a fixed column, so they must not move along with the first element.
+        def hash_elements_aligned_by_argument_alignment?(node)
+          return false if !node.hash_type? || node.braces?
+          return false unless enforce_first_argument_with_fixed_indentation?
+
+          argument_alignment_applies?(node.parent) && !enforce_hash_argument_with_separator?
+        end
+
+        def enforce_hash_argument_with_separator?
+          HashAlignment::SEPARATOR_ALIGNMENT_STYLES.any? do |style|
+            config.for_enabled_cop('Layout/HashAlignment')[style]&.include?('separator')
+          end
+        end
+
         def bare_operator?(node)
           node.operator_method? && !node.dot?
         end

data/lib/rubocop/cop/layout/first_array_element_line_break.rb

@@ -6,6 +6,10 @@ module RuboCop
       # Checks for a line break before the first element in a
       # multi-line array.
       #
+      # NOTE: An array whose first element is an array literal is not checked when
+      # `Layout/SpaceInsideArrayLiteralBrackets` is enabled with `EnforcedStyle: compact`,
+      # since that style joins the two opening brackets.
+      #
       # @example
       #
       #   # bad
@@ -70,6 +74,7 @@ module RuboCop
         def on_array(node)
           return if !node.loc.begin && !assignment_on_same_line?(node)
           return if allow_implicit_array_brackets? && !node.bracketed?
+          return if compact_nested_array?(node)
 
           check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
         end
@@ -85,6 +90,16 @@ module RuboCop
           !!cop_config['AllowImplicitArrayLiterals']
         end
 
+        def compact_nested_array?(node)
+          node.square_brackets? && node.children.first&.source&.start_with?('[') &&
+            compact_array_brackets_enforced?
+        end
+
+        def compact_array_brackets_enforced?
+          config.cop_enabled?('Layout/SpaceInsideArrayLiteralBrackets') &&
+            config.for_cop('Layout/SpaceInsideArrayLiteralBrackets')['EnforcedStyle'] == 'compact'
+        end
+
         def ignore_last_element?
           !!cop_config['AllowMultilineFinalElement']
         end

data/lib/rubocop/cop/layout/first_hash_element_indentation.rb

@@ -156,16 +156,22 @@ module RuboCop
           if first_pair
             return if same_line?(first_pair, left_brace)
 
-            if separator_style?(first_pair)
-              check_based_on_longest_key(hash_node, left_brace, left_parenthesis)
-            else
-              check_first(first_pair, left_brace, left_parenthesis, 0)
-            end
+            check_first_pair(hash_node, first_pair, left_brace, left_parenthesis)
           end
 
           check_right_brace(hash_node.loc.end, first_pair, left_brace, left_parenthesis)
         end
 
+        def check_first_pair(hash_node, first_pair, left_brace, left_parenthesis)
+          return unless begins_its_line?(first_pair.source_range)
+
+          if separator_style?(first_pair)
+            check_based_on_longest_key(hash_node, left_brace, left_parenthesis)
+          else
+            check_first(first_pair, left_brace, left_parenthesis, 0)
+          end
+        end
+
         def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis)
           # if the right brace is on the same line as the last value, accept
           return if /\S/.match?(right_brace.source_line[0...right_brace.column])

data/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb

@@ -57,8 +57,10 @@ module RuboCop
         MSG = 'Put the closing parenthesis for a method call with a ' \
               'HEREDOC parameter on the same line as the HEREDOC opening.'
 
+        # `Layout/MultilineMethodCallBraceLayout` can move the same closing parenthesis after
+        # the last argument in the same pass, and both insertions are kept.
         def self.autocorrect_incompatible_with
-          [Style::TrailingCommaInArguments]
+          [Layout::MultilineMethodCallBraceLayout, Style::TrailingCommaInArguments]
         end
 
         def on_send(node)
@@ -231,8 +233,8 @@ module RuboCop
         end
 
         def find_most_bottom_of_heredoc_end(arguments)
-          arguments.filter_map do |argument|
-            argument.loc.heredoc_end.end_pos if argument.loc?(:heredoc_end)
+          arguments.flat_map { |argument| argument.each_node(:any_str).to_a }.filter_map do |node|
+            node.loc.heredoc_end.end_pos if node.loc?(:heredoc_end)
           end.max
         end
 

data/lib/rubocop/cop/layout/indentation_consistency.rb

@@ -178,10 +178,24 @@ module RuboCop
         end
 
         def check_normal_style(node)
-          check_alignment(
-            node.children.reject { |child| bare_access_modifier?(child) },
-            base_column_for_normal_style(node)
-          )
+          items = node.children.reject { |child| bare_access_modifier?(child) }
+
+          check_alignment(items, base_column_for_normal_style(node) || governed_base_column(items))
+        end
+
+        def governed_base_column(items)
+          return unless config.cop_enabled?('Layout/IndentationWidth')
+          return if items.empty? || indentation_width_enabled_at?(items.first)
+
+          governed_item = items.find { |item| indentation_width_enabled_at?(item) }
+
+          display_column(governed_item.source_range) if governed_item
+        end
+
+        def indentation_width_enabled_at?(node)
+          comment_config = processed_source.comment_config
+
+          comment_config.cop_enabled_at_line?('Layout/IndentationWidth', node.first_line)
         end
 
         def check_indented_internal_methods_style(node)
@@ -197,7 +211,10 @@ module RuboCop
               children_to_check.last << child
             end
           end
-          children_to_check.each { |group| check_alignment(group) }
+
+          children_to_check.each do |group|
+            check_alignment(group, governed_base_column(group))
+          end
         end
       end
     end