rubocop 1.91.0 → 1.92.1

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

@@ -66,16 +66,18 @@ module RuboCop
 
         # @!method bit_operation?(node)
         def_node_matcher :bit_operation?, <<~PATTERN
-          (begin
-            (send _ :& _))
+          {
+            (begin (send _ :& _))
+            (send _ :& _)
+          }
         PATTERN
 
         # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
-          return unless node.receiver&.begin_type?
+          return unless bit_operation?(node.receiver)
           return unless (preferred_method = preferred_method(node))
 
-          bit_operation = node.receiver.children.first
+          bit_operation = node.receiver.begin_type? ? node.receiver.children.first : node.receiver
           lhs, _operator, rhs = *bit_operation
 
           preferred = if preferred_method == 'allbits?' && lhs.source == node.first_argument.source

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

@@ -177,7 +177,7 @@ module RuboCop
         BRACES_REQUIRED_MESSAGE = "Brace delimiters `{...}` required for '%<method_name>s' method."
 
         def self.autocorrect_incompatible_with
-          [Style::RedundantBegin]
+          [Layout::SpaceBeforeBlockBraces, Style::MethodCallWithArgsParentheses, Style::RedundantBegin]
         end
 
         def on_send(node)
@@ -196,6 +196,8 @@ module RuboCop
           end
         end
         alias on_csend on_send
+        alias on_super on_send
+        alias on_yield on_send
 
         def on_block(node)
           return if part_of_ignored_node?(node)
@@ -292,7 +294,7 @@ module RuboCop
           corrector.replace(b, '{')
           corrector.replace(e, '}')
 
-          corrector.wrap(node.body, "begin\n", "\nend") if begin_required?(node)
+          wrap_body_with_begin(corrector, node.body) if begin_required?(node)
         end
 
         def whitespace_before?(range)
@@ -304,6 +306,8 @@ module RuboCop
         end
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
+          return if directive_comment?(comment)
+
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
 
           # It is possible that there is code between the block and the comment
@@ -317,6 +321,10 @@ module RuboCop
           corrector.insert_before(block_node, "#{comment.text}\n")
         end
 
+        def directive_comment?(comment)
+          comment.text.match?(DirectiveComment::DIRECTIVE_COMMENT_REGEXP)
+        end
+
         def source_range_before_comment(range, comment)
           range = range.end.join(comment.source_range.begin)
 
@@ -372,6 +380,7 @@ module RuboCop
         # rubocop:disable-next Metrics/CyclomaticComplexity -- inlined special_method checks to avoid double evaluation
         def proper_block_style?(node)
           return true if require_do_end?(node)
+          return true if collection_of_for_loop?(node)
 
           method_name = node.method_name
           return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
@@ -398,6 +407,10 @@ module RuboCop
           !modifier_rescue?(body)
         end
 
+        def collection_of_for_loop?(node)
+          node.parent&.for_type? && node.parent.collection == node
+        end
+
         def modifier_rescue?(rescue_node)
           return false if rescue_node.body.nil? || rescue_node.else_branch
           return false unless rescue_node.resbody_branches.one?
@@ -438,11 +451,20 @@ module RuboCop
         end
 
         def correction_would_break_code?(node)
-          return false unless node.keywords?
+          return loop_condition?(node) if node.braces?
 
           node.send_node.arguments? && !node.send_node.parenthesized?
         end
 
+        # A `do` in the condition of `while` or `until` is taken as the start of
+        # the loop body. Inside the body of another block it is unambiguous again.
+        def loop_condition?(node)
+          ancestors = node.each_ancestor.take_while { |ancestor| !ancestor.any_block_type? }
+          [node, *ancestors].each_cons(2).any? do |child, parent|
+            parent.type?(:while, :until) && parent.condition.equal?(child)
+          end
+        end
+
         def functional_method?(method_name)
           functional_methods.include?(method_name)
         end
@@ -490,6 +512,16 @@ module RuboCop
           node.type?(:array, :range)
         end
 
+        def wrap_body_with_begin(corrector, body)
+          heredoc_ends = body.each_node(:any_str).select(&:heredoc?).map do |str|
+            str.loc.heredoc_end
+          end
+          body_end = [body.source_range, *heredoc_ends].max_by(&:end_pos)
+
+          corrector.insert_before(body, "begin\n")
+          corrector.insert_after(body_end, "\nend")
+        end
+
         def begin_required?(block_node)
           # If the block contains `rescue` or `ensure`, it needs to be wrapped in
           # `begin`...`end` when changing `do-end` to `{}`.

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

@@ -54,6 +54,10 @@ module RuboCop
 
         MSG = 'Convert `if-elsif` to `case-when`.'
 
+        def self.autocorrect_incompatible_with
+          [Style::IfInsideElse]
+        end
+
         def on_if(node)
           return unless should_check?(node)
 
@@ -224,10 +228,9 @@ module RuboCop
         end
 
         def branch_conditions(node)
-          conditions = []
-          while node&.if_type? && !node.ternary?
+          conditions = [node.condition]
+          while (node = node.else_branch)&.if_type? && node.elsif?
             conditions << node.condition
-            node = node.else_branch
           end
           conditions
         end

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

@@ -65,6 +65,12 @@ module RuboCop
         NESTED_MSG = 'Use nested module/class definitions instead of compact style.'
         COMPACT_MSG = 'Use compact module/class definition instead of nested style.'
 
+        # `Style/StructInheritance` turns a class definition into a constant assignment in
+        # the same pass, which the compacted `class` keyword would then precede.
+        def self.autocorrect_incompatible_with
+          [Style::StructInheritance]
+        end
+
         def on_class(node)
           return if node.parent_class && style_for_classes != :nested
 
@@ -117,7 +123,10 @@ module RuboCop
         end
 
         def heuristic_namespace_keyword(node)
-          class_definition = node.left_sibling&.each_node(:class)&.find do |class_node|
+          left_sibling = node.left_sibling
+          return 'module' unless left_sibling.is_a?(AST::Node)
+
+          class_definition = left_sibling.each_node(:class).find do |class_node|
             class_node.identifier == node.identifier.namespace
           end
 
@@ -143,7 +152,9 @@ module RuboCop
           # making autocorrection ping-pong between the two forms.
           return if style_for_kind(node.body.type) == :nested
           return unless compactible_namespace?(node)
+          return if node.each_ancestor(:class, :module).any? { |ancestor| ignored_node?(ancestor) }
 
+          ignore_node(node)
           compact_node(corrector, node)
           remove_end(corrector, node.body)
           unindent(corrector, node)
@@ -194,33 +205,62 @@ module RuboCop
             "#{node.body.children.first.const_name}"
         end
 
-        # rubocop:disable-next Metrics/AbcSize
         def remove_end(corrector, body)
-          remove_begin_pos = if same_line?(body.loc.name, body.loc.end)
-                               body.loc.name.end_pos
-                             else
-                               body.loc.end.begin_pos - leading_spaces(body).size
-                             end
-          adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
-          range = range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
+          range = if same_line?(body.loc.name, body.loc.end)
+                    single_line_end_range(body)
+                  else
+                    multiline_end_range(body)
+                  end
 
           corrector.remove(range)
         end
 
-        def unindent(corrector, node)
-          return unless node.body.children.last
+        def single_line_end_range(body)
+          raw = processed_source.raw_source
+          pos = body.loc.end.begin_pos
+          pos -= 1 while raw[pos - 1] == ' '
+          pos -= 1 if raw[pos - 1] == ';'
+          range_between(pos, body.loc.end.end_pos)
+        end
 
-          last_child_leading_spaces = leading_spaces(node.body.children.last)
-          return if spaces_size(leading_spaces(node)) == spaces_size(last_child_leading_spaces)
+        def multiline_end_range(body)
+          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
+          range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
+        end
 
-          column_delta = configured_indentation_width - spaces_size(last_child_leading_spaces)
-          return if column_delta.zero?
+        def unindent(corrector, node)
+          column_delta = unindent_column_delta(node)
+          return unless column_delta&.negative?
+
+          range = unindentable_range(node.body)
+          return unless range
 
           AlignmentCorrector.correct(
-            corrector, processed_source, node, column_delta, tab_indentation: true
+            corrector, processed_source, range, column_delta, tab_indentation: true
           )
         end
 
+        def unindent_column_delta(node)
+          body = node.body.children.last
+          return unless body
+
+          node_indentation = spaces_size(leading_spaces(node))
+          body_indentation = spaces_size(leading_spaces(body))
+
+          node_indentation + configured_indentation_width - body_indentation
+        end
+
+        def unindentable_range(body)
+          first_line = body.loc.name.line + 1
+          last_line = body.loc.end.line - 1
+          return if first_line > last_line
+
+          buffer = processed_source.buffer
+          range_between(buffer.line_range(first_line).begin_pos,
+                        buffer.line_range(last_line).end_pos)
+        end
+
         def leading_spaces(node)
           node.source_range.source_line[/\A\s*/]
         end

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

@@ -72,9 +72,13 @@ module RuboCop
           return unless def_self_style?
           return unless node.identifier.self_type?
           return unless all_methods_public?(node)
+          return unless def_nodes(node).all? { |def_node| no_code_after?(def_node.source_range) }
 
           add_offense(node, message: MSG_SCLASS) do |corrector|
+            next if inside_corrected_sclass?(node)
+
             autocorrect_sclass(node, corrector)
+            ignore_node(node)
           end
         end
 
@@ -112,6 +116,17 @@ module RuboCop
           end
         end
 
+        def no_code_after?(range)
+          trailing = processed_source.lines[range.last_line - 1][range.last_column..].to_s.strip
+          trailing = trailing.sub(/\A;+\s*/, '')
+
+          trailing.empty? || trailing.start_with?('#')
+        end
+
+        def inside_corrected_sclass?(node)
+          node.each_ancestor(:sclass).any? { |ancestor| ignored_node?(ancestor) }
+        end
+
         def autocorrect_sclass(node, corrector)
           rewritten_defs = []
 

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

@@ -15,31 +15,24 @@ module RuboCop
       # would yield false positives. For example, `String` implements `length`
       # and `size`, but it doesn't include `Enumerable`.
       #
+      # When `count` is used without a block, it measures the collection's
+      # size, so the offense is corrected to `empty?` or `!empty?`. The
+      # predicate methods `any?`, `none?` and `one?` test element truthiness
+      # instead and would return different results for collections with falsey
+      # elements (e.g. `[false].count.zero?` is `false`, but `[false].none?`
+      # is `true`). For the same reason, `count == 1` and `count > 1` without
+      # a block are not flagged.
+      #
       # @safety
       #   The cop is unsafe because receiver might not include `Enumerable`, or
       #   it has nonstandard implementation of `count` or any replacement
       #   methods.
       #
-      #   It's also unsafe because for collections with falsey values, expressions
-      #   with `count` without a block return a different result than methods `any?`,
-      #   `none?` and `one?`:
-      #
-      #   [source,ruby]
-      #   ----
-      #   [nil, false].count.positive?
-      #   [nil].count == 1
-      #   # => true
-      #
-      #   [nil, false].any?
-      #   [nil].one?
-      #   # => false
-      #
-      #   [nil].count == 0
-      #   # => false
-      #
-      #   [nil].none?
-      #   # => true
-      #   ----
+      #   Blockless `count` is corrected to `empty?`, which `Enumerable` doesn't
+      #   define. `Range`, `Enumerator` (including lazy ones), `Struct`, `StringIO`
+      #   and any class that just includes `Enumerable` respond to `count` but not
+      #   to `empty?`, so `(1...1).count.zero?` is `true` while `(1...1).empty?`
+      #   raises `NoMethodError`.
       #
       #   Autocorrection is unsafe when replacement methods don't iterate over
       #   every element in collection and the given block runs side effects:
@@ -60,12 +53,14 @@ module RuboCop
       #   x.count > 0
       #   x.count != 0
       #
+      #   # good
+      #   !x.empty?
+      #
+      #   # bad
       #   x.count(&:foo?).positive?
       #   x.count { |item| item.foo? }.positive?
       #
       #   # good
-      #   x.any?
-      #
       #   x.any?(&:foo?)
       #   x.any? { |item| item.foo? }
       #
@@ -74,24 +69,33 @@ module RuboCop
       #   x.count == 0
       #
       #   # good
-      #   x.none?
+      #   x.empty?
       #
       #   # bad
-      #   x.count == 1
-      #   x.one?
+      #   x.count(&:foo?).zero?
+      #   x.count(&:foo?) == 0
+      #
+      #   # good
+      #   x.none?(&:foo?)
+      #
+      #   # bad
+      #   x.count(&:foo?) == 1
+      #
+      #   # good
+      #   x.one?(&:foo?)
       #
       # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
       #
       #   # good
-      #   x.count > 1
+      #   x.count(&:foo?) > 1
       #
       # @example AllCops:ActiveSupportExtensionsEnabled: true
       #
       #   # bad
-      #   x.count > 1
+      #   x.count(&:foo?) > 1
       #
       #   # good
-      #   x.many?
+      #   x.many?(&:foo?)
       #
       class CollectionQuerying < Base
         include RangeHelp
@@ -102,13 +106,21 @@ module RuboCop
         RESTRICT_ON_SEND = %i[positive? > != zero? ==].freeze
 
         REPLACEMENTS = {
-          [:positive?, nil] => :any?,
-          [:>, 0] => :any?,
-          [:!=, 0] => :any?,
-          [:zero?, nil] => :none?,
-          [:==, 0] => :none?,
-          [:==, 1] => :one?,
-          [:>, 1] => :many?
+          [:positive?, nil] => 'any?',
+          [:>, 0] => 'any?',
+          [:!=, 0] => 'any?',
+          [:zero?, nil] => 'none?',
+          [:==, 0] => 'none?',
+          [:==, 1] => 'one?',
+          [:>, 1] => 'many?'
+        }.freeze
+
+        NO_BLOCK_REPLACEMENTS = {
+          [:positive?, nil] => '!empty?',
+          [:>, 0] => '!empty?',
+          [:!=, 0] => '!empty?',
+          [:zero?, nil] => 'empty?',
+          [:==, 0] => 'empty?'
         }.freeze
 
         # @!method count_predicate(node)
@@ -132,28 +144,49 @@ module RuboCop
         def on_send(node)
           return unless (count_node = count_predicate(node))
 
-          replacement_method = replacement_method(node)
+          replacement = replacement_method(node, count_node)
 
-          return unless replacement_supported?(replacement_method)
+          return unless replacement_supported?(node, replacement)
 
           offense_range = count_node.loc.selector.join(node.source_range.end)
-          add_offense(offense_range,
-                      message: format(MSG, prefer: replacement_method)) do |corrector|
-            corrector.replace(count_node.loc.selector, replacement_method)
-            corrector.remove(removal_range(node))
+          add_offense(offense_range, message: format(MSG, prefer: replacement)) do |corrector|
+            autocorrect(corrector, node, count_node, replacement)
           end
         end
 
         private
 
-        def replacement_method(node)
-          REPLACEMENTS.fetch([node.method_name, node.first_argument&.value])
+        def replacement_method(node, count_node)
+          key = [node.method_name, node.first_argument&.value]
+          return REPLACEMENTS.fetch(key) if block_given_to_count?(count_node)
+
+          NO_BLOCK_REPLACEMENTS[key]
+        end
+
+        def block_given_to_count?(count_node)
+          count_node.parent&.any_block_type? || count_node.last_argument&.block_pass_type?
+        end
+
+        def replacement_supported?(node, replacement)
+          return false unless replacement
+          return false if replacement == 'many?' && !active_support_extensions_enabled?
+
+          !(replacement.start_with?('!') && receiver_of_call?(node))
         end
 
-        def replacement_supported?(method_name)
-          return true if active_support_extensions_enabled?
+        def receiver_of_call?(node)
+          node.parent&.call_type? && node.parent.receiver == node && node.parent.loc.dot
+        end
+
+        def autocorrect(corrector, node, count_node, replacement)
+          if replacement.start_with?('!')
+            corrector.insert_before(count_node, '!')
+            corrector.replace(count_node.loc.selector, 'empty?')
+          else
+            corrector.replace(count_node.loc.selector, replacement)
+          end
 
-          method_name != :many?
+          corrector.remove(removal_range(node))
         end
 
         def removal_range(node)

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

@@ -60,19 +60,22 @@ module RuboCop
       #   end
       #
       class CombinableLoops < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Combine this loop with the previous loop.'
 
-        # rubocop:disable-next Metrics/CyclomaticComplexity
+        def self.autocorrect_incompatible_with
+          [Layout::BlockEndNewline, Layout::RedundantLineBreak]
+        end
+
         def on_block(node)
           return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)
-          return unless same_collection_looping_block?(node, node.left_sibling)
-          return unless node.body && node.left_sibling.body
+          return unless combinable_looping_blocks?(node, node.left_sibling)
 
           add_offense(node) do |corrector|
-            next unless node.arguments == node.left_sibling.arguments
+            next unless combinable_blocks?(node, node.left_sibling)
 
             combine_with_left_sibling(corrector, node)
           end
@@ -87,9 +90,7 @@ module RuboCop
           return unless node.body && node.left_sibling.body
 
           add_offense(node) do |corrector|
-            # Combining loops with different iteration variables would leave the second
-            # body referencing an undefined variable, so only autocorrect when they match.
-            next unless node.variable == node.left_sibling.variable
+            next unless combinable_fors?(node, node.left_sibling)
 
             combine_with_left_sibling(corrector, node)
           end
@@ -110,25 +111,102 @@ module RuboCop
             sibling.send_node.arguments == node.send_node.arguments
         end
 
+        def combinable_looping_blocks?(node, sibling)
+          same_collection_looping_block?(node, sibling) && node.body && sibling.body
+        end
+
         def same_collection_looping_for?(node, sibling)
           sibling&.for_type? && node.collection == sibling.collection
         end
 
+        def combinable_blocks?(node, sibling)
+          return false unless node.arguments == sibling.arguments
+          # Numbered and `it` parameters are implicit, so `arguments` is empty for both.
+          return false unless node.argument_list == sibling.argument_list
+          return false if directive_after_opening?(node)
+
+          !node.body.type?(:rescue, :ensure) && !sibling.body.type?(:rescue, :ensure)
+        end
+
+        # Combining loops with different iteration variables would leave the second
+        # body referencing an undefined variable, so only autocorrect when they match.
+        def combinable_fors?(node, sibling)
+          node.variable == sibling.variable && !directive_after_opening?(node)
+        end
+
+        # The opening is removed, so a directive after it would end up on a line of
+        # its own, where it covers the rest of the file instead of a single line.
+        def directive_after_opening?(node)
+          opening_line = loop_opening(node).line
+          return false if opening_line == node.body.first_line
+
+          comment = processed_source.comment_at_line(opening_line)
+          comment && DirectiveComment.new(comment).start_with_marker?
+        end
+
+        # The block arguments or `{`/`do` of a block, or the `do` or collection of a `for` loop.
+        def loop_opening(node)
+          if node.for_type?
+            node.loc.begin || node.collection.source_range
+          else
+            (node.block_type? && node.arguments.source_range) || node.loc.begin
+          end
+        end
+
         def combine_with_left_sibling(corrector, node)
-          corrector.remove(node.left_sibling.body.source_range.end.join(node.left_sibling.loc.end))
-          corrector.remove(node.source_range.begin.join(node.body.source_range.begin))
+          corrector.remove(closing_with_preceding_space(node.left_sibling, node))
+          corrector.remove(opening_with_following_space(node))
 
           correct_end_of_block(corrector, node)
         end
 
+        # Comments and heredoc bodies before the closing delimiter are kept. When
+        # the next loop starts on the delimiter's line, the line break before the
+        # delimiter is kept too, so that a comment doesn't swallow the next loop.
+        def closing_with_preceding_space(loop, next_loop)
+          separate_lines = !same_line?(loop.loc.end, next_loop)
+
+          range_with_surrounding_space(
+            loop.loc.end, side: :left, newlines: separate_lines, whitespace: separate_lines
+          )
+        end
+
+        # Comments between the opening and the body are kept.
+        def opening_with_following_space(node)
+          opening = node.source_range.begin.join(loop_opening(node))
+
+          range_with_surrounding_space(opening, side: :right, whitespace: true)
+        end
+
         def correct_end_of_block(corrector, node)
           return unless node.left_sibling.respond_to?(:braces?)
-          return if node.right_sibling&.any_block_type?
+          return if combined_with_right_sibling?(node)
 
-          end_of_block = node.left_sibling.braces? ? '}' : ' end'
+          end_of_block = first_combined_block(node).braces? ? '}' : ' end'
           corrector.remove(node.loc.end)
           corrector.insert_before(node.source_range.end, end_of_block)
         end
+
+        def combined_with_right_sibling?(node)
+          sibling = node.right_sibling
+          return false unless sibling&.any_block_type?
+          # A disabled loop isn't corrected, so it doesn't get merged into this one.
+          return false unless enabled_lines?(sibling.source_range)
+
+          same_collection_looping_block?(sibling, node) && sibling.body &&
+            combinable_blocks?(sibling, node)
+        end
+
+        def first_combined_block(node)
+          first = node.left_sibling
+
+          while (previous = first.left_sibling) && enabled_lines?(first.source_range) &&
+                combinable_looping_blocks?(first, previous) && combinable_blocks?(first, previous)
+            first = previous
+          end
+
+          first
+        end
       end
     end
   end