rubocop 1.57.1 → 1.81.6

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

@@ -106,7 +106,7 @@ module RuboCop
           when :or
             find_target(node.lhs)
           when :match_with_lvasgn
-            lhs, rhs = *node
+            lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
             if lhs.regexp_type?
               rhs
             elsif rhs.regexp_type?
@@ -125,7 +125,7 @@ module RuboCop
           when :==, :eql?, :equal?
             find_target_in_equality_node(node)
           when :===
-            node.arguments.first
+            node.first_argument
           when :include?, :cover?
             find_target_in_include_or_cover_node(node)
           when :match, :match?, :=~
@@ -134,7 +134,7 @@ module RuboCop
         end
 
         def find_target_in_equality_node(node)
-          argument = node.arguments.first
+          argument = node.first_argument
           receiver = node.receiver
           return unless argument && receiver
 
@@ -152,7 +152,7 @@ module RuboCop
         end
 
         def find_target_in_match_node(node)
-          argument = node.arguments.first
+          argument = node.first_argument
           receiver = node.receiver
           return unless receiver
 
@@ -172,7 +172,7 @@ module RuboCop
               return collect_conditions(node.lhs, target, conditions) &&
                      collect_conditions(node.rhs, target, conditions)
             when :match_with_lvasgn
-              lhs, rhs = *node
+              lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
               condition_from_binary_op(lhs, rhs, target)
             when :send
               condition_from_send_node(node, target)
@@ -185,14 +185,13 @@ module RuboCop
         def condition_from_send_node(node, target)
           case node.method_name
           when :is_a?
-            node.arguments.first if node.receiver == target
+            node.first_argument if node.receiver == target
           when :==, :eql?, :equal?
             condition_from_equality_node(node, target)
           when :=~, :match, :match?
             condition_from_match_node(node, target)
           when :===
-            lhs, _method, rhs = *node
-            lhs if rhs == target
+            node.receiver if node.first_argument == target
           when :include?, :cover?
             condition_from_include_or_cover_node(node, target)
           end
@@ -200,14 +199,12 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity
 
         def condition_from_equality_node(node, target)
-          lhs, _method, rhs = *node
-          condition = condition_from_binary_op(lhs, rhs, target)
+          condition = condition_from_binary_op(node.receiver, node.first_argument, target)
           condition if condition && !class_reference?(condition)
         end
 
         def condition_from_match_node(node, target)
-          lhs, _method, rhs = *node
-          condition_from_binary_op(lhs, rhs, target)
+          condition_from_binary_op(node.receiver, node.first_argument, target)
         end
 
         def condition_from_include_or_cover_node(node, target)
@@ -230,7 +227,7 @@ module RuboCop
 
         def branch_conditions(node)
           conditions = []
-          while node&.if_type?
+          while node&.if_type? && !node.ternary?
             conditions << node.condition
             node = node.else_branch
           end
@@ -263,16 +260,16 @@ module RuboCop
         def regexp_with_working_captures?(node)
           case node.type
           when :match_with_lvasgn
-            lhs, _rhs = *node
+            lhs, _rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
             node.loc.selector.source == '=~' && regexp_with_named_captures?(lhs)
           when :send
-            lhs, method, rhs = *node
-            method == :match && [lhs, rhs].any? { |n| regexp_with_named_captures?(n) }
+            node.method?(:match) &&
+              [node.receiver, node.first_argument].any? { |n| regexp_with_named_captures?(n) }
           end
         end
 
         def regexp_with_named_captures?(node)
-          node.regexp_type? && node.each_capture(named: true).count.positive?
+          node.regexp_type? && node.each_capture(named: true).any?
         end
       end
     end

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

@@ -3,14 +3,26 @@
 module RuboCop
   module Cop
     module Style
-      # Checks the style of children definitions at classes and
-      # modules. Basically there are two different styles:
+      # Checks that namespaced classes and modules are defined with a consistent style.
+      #
+      # With `nested` style, classes and modules should be defined separately (one constant
+      # on each line, without `::`). With `compact` style, classes and modules should be
+      # defined with fully qualified names (using `::` for namespaces).
+      #
+      # NOTE: The style chosen will affect `Module.nesting` for the class or module. Using
+      # `nested` style will result in each level being added, whereas `compact` style will
+      # only include the fully qualified class or module name.
+      #
+      # By default, `EnforcedStyle` applies to both classes and modules. If desired, separate
+      # styles can be defined for classes and modules by using `EnforcedStyleForClasses` and
+      # `EnforcedStyleForModules` respectively. If not set, or set to nil, the `EnforcedStyle`
+      # value will be used.
       #
       # @safety
       #   Autocorrection is unsafe.
       #
-      #   Moving from compact to nested children requires knowledge of whether the
-      #   outer parent is a module or a class. Moving from nested to compact requires
+      #   Moving from `compact` to `nested` children requires knowledge of whether the
+      #   outer parent is a module or a class. Moving from `nested` to `compact` requires
       #   verification that the outer parent is defined elsewhere. RuboCop does not
       #   have the knowledge to perform either operation safely and thus requires
       #   manual oversight.
@@ -42,16 +54,18 @@ module RuboCop
         def on_class(node)
           return if node.parent_class && style != :nested
 
-          check_style(node, node.body)
+          check_style(node, node.body, style_for_classes)
         end
 
         def on_module(node)
-          check_style(node, node.body)
+          check_style(node, node.body, style_for_modules)
         end
 
         private
 
         def nest_or_compact(corrector, node)
+          style = node.class_type? ? style_for_classes : style_for_modules
+
           if style == :nested
             nest_definition(corrector, node)
           else
@@ -117,18 +131,27 @@ module RuboCop
             "#{node.body.children.first.const_name}"
         end
 
+        # rubocop:disable Metrics/AbcSize
         def remove_end(corrector, body)
-          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          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)
 
           corrector.remove(range)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def unindent(corrector, node)
-          return if node.body.children.last.nil?
+          return unless node.body.children.last
 
-          column_delta = configured_indentation_width - leading_spaces(node.body.children.last).size
+          last_child_leading_spaces = leading_spaces(node.body.children.last)
+          return if spaces_size(leading_spaces(node)) == spaces_size(last_child_leading_spaces)
+
+          column_delta = configured_indentation_width - spaces_size(last_child_leading_spaces)
           return if column_delta.zero?
 
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
@@ -138,7 +161,17 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def check_style(node, body)
+        def spaces_size(spaces_string)
+          mapping = { "\t" => tab_indentation_width }
+          spaces_string.chars.sum { |character| mapping.fetch(character, 1) }
+        end
+
+        def tab_indentation_width
+          config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
+            configured_indentation_width
+        end
+
+        def check_style(node, body, style)
           return if node.identifier.namespace&.cbase_type?
 
           if style == :nested
@@ -158,7 +191,7 @@ module RuboCop
 
         def check_compact_style(node, body)
           parent = node.parent
-          return if parent&.class_type? || parent&.module_type?
+          return if parent&.type?(:class, :module)
 
           return unless needs_compacting?(body)
 
@@ -180,6 +213,14 @@ module RuboCop
         def compact_node_name?(node)
           node.identifier.source.include?('::')
         end
+
+        def style_for_classes
+          cop_config['EnforcedStyleForClasses'] || style
+        end
+
+        def style_for_modules
+          cop_config['EnforcedStyleForModules'] || style
+        end
       end
     end
   end

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

@@ -40,6 +40,7 @@ module RuboCop
             corrector.replace(node.loc.selector, replacement)
           end
         end
+        alias on_csend on_send
 
         def message(node)
           if node.method?(:is_a?)

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

@@ -68,7 +68,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          def_node = node.each_ancestor(:def, :defs).first
+          def_node = node.each_ancestor(:any_def).first
           return if def_node &&
                     (allowed_method?(def_node.method_name) ||
                     matches_allowed_pattern?(def_node.method_name))

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

@@ -54,9 +54,9 @@ module RuboCop
         end
 
         def on_send(node)
-          add_offense(
-            node.first_argument, message: format(MSG, class_var: node.first_argument.source)
-          )
+          return unless (first_argument = node.first_argument)
+
+          add_offense(first_argument, message: format(MSG, class_var: first_argument.source))
         end
       end
     end

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

@@ -19,10 +19,11 @@ module RuboCop
       # @example
       #   # bad
       #   array.reject(&:nil?)
-      #   array.delete_if(&:nil?)
       #   array.reject { |e| e.nil? }
-      #   array.delete_if { |e| e.nil? }
       #   array.select { |e| !e.nil? }
+      #   array.filter { |e| !e.nil? }
+      #   array.grep_v(nil)
+      #   array.grep_v(NilClass)
       #
       #   # good
       #   array.compact
@@ -31,6 +32,7 @@ module RuboCop
       #   hash.reject!(&:nil?)
       #   hash.reject! { |k, v| v.nil? }
       #   hash.select! { |k, v| !v.nil? }
+      #   hash.filter! { |k, v| !v.nil? }
       #
       #   # good
       #   hash.compact!
@@ -46,14 +48,15 @@ module RuboCop
         extend TargetRubyVersion
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-        RESTRICT_ON_SEND = %i[reject delete_if reject! select select!].freeze
+        RESTRICT_ON_SEND = %i[reject reject! select select! filter filter! grep_v].freeze
         TO_ENUM_METHODS = %i[to_enum lazy].freeze
+        FILTER_METHODS = %i[filter filter!].freeze
 
         minimum_target_ruby_version 2.4
 
         # @!method reject_method_with_block_pass?(node)
         def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
-          (send !nil? {:reject :delete_if :reject!}
+          (call !nil? {:reject :reject!}
             (block_pass
               (sym :nil?)))
         PATTERN
@@ -61,41 +64,47 @@ module RuboCop
         # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
-            (send
-              !nil? {:reject :delete_if :reject!})
+            (call
+              !nil? {:reject :reject!})
             $(args ...)
-            (send
+            (call
               $(lvar _) :nil?))
         PATTERN
 
         # @!method select_method?(node)
         def_node_matcher :select_method?, <<~PATTERN
           (block
-            (send
-              !nil? {:select :select!})
+            (call
+              !nil? {:select :select! :filter :filter!})
             $(args ...)
-            (send
-              (send
+            (call
+              (call
                 $(lvar _) :nil?) :!))
         PATTERN
 
+        # @!method grep_v_with_nil?(node)
+        def_node_matcher :grep_v_with_nil?, <<~PATTERN
+          (send _ :grep_v {(nil) (const {nil? cbase} :NilClass)})
+        PATTERN
+
         def on_send(node)
+          return if target_ruby_version < 2.6 && FILTER_METHODS.include?(node.method_name)
           return unless (range = offense_range(node))
           return if allowed_receiver?(node.receiver)
-          if (target_ruby_version <= 3.0 || node.method?(:delete_if)) && to_enum_method?(node)
-            return
-          end
+          return if target_ruby_version <= 3.0 && to_enum_method?(node)
 
           good = good_method_name(node)
           message = format(MSG, good: good, bad: range.source)
 
           add_offense(range, message: message) { |corrector| corrector.replace(range, good) }
         end
+        alias on_csend on_send
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def offense_range(node)
-          if reject_method_with_block_pass?(node)
+          if reject_method_with_block_pass?(node) || grep_v_with_nil?(node)
             range(node, node)
           else
             block_node = node.parent
@@ -109,6 +118,7 @@ module RuboCop
             range(node, block_node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def to_enum_method?(node)
           return false unless node.receiver.send_type?

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

@@ -49,14 +49,15 @@ module RuboCop
         def on_block(node)
           check_method_node(node.send_node)
         end
-
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_send(node)
           return unless implicit_block?(node)
 
           check_method_node(node)
         end
+        alias on_csend on_send
 
         private
 

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer `Enumerable` predicate methods over expressions with `count`.
+      #
+      # The cop checks calls to `count` without arguments, or with a
+      # block. It doesn't register offenses for `count` with a positional
+      # argument because its behavior differs from predicate methods (`count`
+      # matches the argument using `==`, while `any?`, `none?` and `one?` use
+      # `===`).
+      #
+      # NOTE: This cop doesn't check `length` and `size` methods because they
+      # would yield false positives. For example, `String` implements `length`
+      # and `size`, but it doesn't include `Enumerable`.
+      #
+      # @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
+      #   ----
+      #
+      #   Autocorrection is unsafe when replacement methods don't iterate over
+      #   every element in collection and the given block runs side effects:
+      #
+      #   [source,ruby]
+      #   ----
+      #   x.count(&:method_with_side_effects).positive?
+      #   # calls `method_with_side_effects` on every element
+      #
+      #   x.any?(&:method_with_side_effects)
+      #   # calls `method_with_side_effects` until first element returns a truthy value
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   x.count.positive?
+      #   x.count > 0
+      #   x.count != 0
+      #
+      #   x.count(&:foo?).positive?
+      #   x.count { |item| item.foo? }.positive?
+      #
+      #   # good
+      #   x.any?
+      #
+      #   x.any?(&:foo?)
+      #   x.any? { |item| item.foo? }
+      #
+      #   # bad
+      #   x.count.zero?
+      #   x.count == 0
+      #
+      #   # good
+      #   x.none?
+      #
+      #   # bad
+      #   x.count == 1
+      #   x.one?
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #
+      #   # good
+      #   x.count > 1
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #
+      #   # bad
+      #   x.count > 1
+      #
+      #   # good
+      #   x.many?
+      #
+      class CollectionQuerying < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead.'
+
+        RESTRICT_ON_SEND = %i[positive? > != zero? ==].freeze
+
+        REPLACEMENTS = {
+          [:positive?, nil] => :any?,
+          [:>, 0] => :any?,
+          [:!=, 0] => :any?,
+          [:zero?, nil] => :none?,
+          [:==, 0] => :none?,
+          [:==, 1] => :one?,
+          [:>, 1] => :many?
+        }.freeze
+
+        # @!method count_predicate(node)
+        def_node_matcher :count_predicate, <<~PATTERN
+          (send
+            {
+              (any_block $(call !nil? :count) _ _)
+              $(call !nil? :count (block-pass _)?)
+            }
+            {
+              :positive? |
+              :> (int 0) |
+              :!= (int 0) |
+              :zero? |
+              :== (int 0) |
+              :== (int 1) |
+              :> (int 1)
+            })
+        PATTERN
+
+        def on_send(node)
+          return unless (count_node = count_predicate(node))
+
+          replacement_method = replacement_method(node)
+
+          return unless replacement_supported?(replacement_method)
+
+          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))
+          end
+        end
+
+        private
+
+        def replacement_method(node)
+          REPLACEMENTS.fetch([node.method_name, node.first_argument&.value])
+        end
+
+        def replacement_supported?(method_name)
+          return true if active_support_extensions_enabled?
+
+          method_name != :many?
+        end
+
+        def removal_range(node)
+          range = (node.loc.dot || node.loc.selector).join(node.source_range.end)
+
+          range_with_surrounding_space(range, side: :left)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for multiple `defined?` calls joined by `&&` that can be combined
+      # into a single `defined?`.
+      #
+      # When checking that a nested constant or chained method is defined, it is
+      # not necessary to check each ancestor or component of the chain.
+      #
+      # @example
+      #   # bad
+      #   defined?(Foo) && defined?(Foo::Bar) && defined?(Foo::Bar::Baz)
+      #
+      #   # good
+      #   defined?(Foo::Bar::Baz)
+      #
+      #   # bad
+      #   defined?(foo) && defined?(foo.bar) && defined?(foo.bar.baz)
+      #
+      #   # good
+      #   defined?(foo.bar.baz)
+      class CombinableDefined < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Combine nested `defined?` calls.'
+        OPERATORS = %w[&& and].freeze
+
+        def on_and(node)
+          # Only register an offense if all `&&` terms are `defined?` calls
+          return unless (terms = terms(node)).all?(&:defined_type?)
+
+          calls = defined_calls(terms)
+          namespaces = namespaces(calls)
+
+          calls.each do |call|
+            next unless namespaces.any?(call)
+
+            add_offense(node) do |corrector|
+              remove_term(corrector, call)
+            end
+          end
+        end
+
+        private
+
+        def terms(node)
+          node.each_descendant.select do |descendant|
+            descendant.parent.and_type? && !descendant.and_type?
+          end
+        end
+
+        def defined_calls(nodes)
+          nodes.filter_map do |defined_node|
+            subject = defined_node.first_argument
+            subject if subject.type?(:const, :call)
+          end
+        end
+
+        def namespaces(nodes)
+          nodes.filter_map do |node|
+            if node.respond_to?(:namespace)
+              node.namespace
+            elsif node.respond_to?(:receiver)
+              node.receiver
+            end
+          end
+        end
+
+        def remove_term(corrector, term)
+          term = term.parent until term.parent.and_type?
+          range = if term == term.parent.children.last
+                    rhs_range_to_remove(term)
+                  else
+                    lhs_range_to_remove(term)
+                  end
+
+          corrector.remove(range)
+        end
+
+        # If the redundant `defined?` node is the LHS of an `and` node,
+        # the term as well as the subsequent `&&`/`and` operator will be removed.
+        def lhs_range_to_remove(term)
+          source = @processed_source.buffer.source
+
+          pos = term.source_range.end_pos
+          pos += 1 until source[..pos].end_with?(*OPERATORS)
+
+          range_with_surrounding_space(
+            range: term.source_range.with(end_pos: pos + 1),
+            side: :right,
+            newlines: false
+          )
+        end
+
+        # If the redundant `defined?` node is the RHS of an `and` node,
+        # the term as well as the preceding `&&`/`and` operator will be removed.
+        def rhs_range_to_remove(term)
+          source = @processed_source.buffer.source
+
+          pos = term.source_range.begin_pos
+          pos -= 1 until source[pos, 3].start_with?(*OPERATORS)
+
+          range_with_surrounding_space(
+            range: term.source_range.with(begin_pos: pos - 1),
+            side: :right,
+            newlines: false
+          )
+        end
+      end
+    end
+  end
+end