rubocop 1.79.2 → 1.88.0

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks that each source file defines at most one top-level class or module.
+      #
+      # Keeping one class or module per file makes it easier to find and navigate
+      # code, and follows the convention used by most Ruby projects.
+      #
+      # Classes and modules listed in `AllowedClasses` are not counted toward the
+      # limit. This is useful for small ancillary classes like custom exception
+      # classes that logically belong with the main class.
+      #
+      # @example
+      #   # bad - Multiple top-level classes
+      #   class Foo
+      #   end
+      #
+      #   class Bar
+      #   end
+      #
+      #   # bad - Multiple top-level modules
+      #   module Foo
+      #   end
+      #
+      #   module Bar
+      #   end
+      #
+      #   # bad - A top-level class and a top-level module
+      #   class Foo
+      #   end
+      #
+      #   module Bar
+      #   end
+      #
+      #   # good - A single top-level class
+      #   class Foo
+      #   end
+      #
+      #   # good - A single top-level module
+      #   module Foo
+      #   end
+      #
+      #   # good - Nested classes within a single top-level class
+      #   class Foo
+      #     class Bar
+      #     end
+      #   end
+      #
+      #   # good - Multiple classes within a single top-level module
+      #   module Foo
+      #     class Bar
+      #     end
+      #
+      #     class Baz
+      #     end
+      #   end
+      #
+      # @example AllowedClasses: ['AllowedClass']
+      #   # good
+      #   class Foo
+      #   end
+      #
+      #   class AllowedClass
+      #   end
+      #
+      class OneClassPerFile < Base
+        include RangeHelp
+
+        MSG = 'Do not define multiple classes/modules at the top level in a single file.'
+
+        def on_new_investigation
+          @top_level_definitions = []
+        end
+
+        def on_class(node)
+          check_top_level(node)
+        end
+
+        def on_module(node)
+          check_top_level(node)
+        end
+
+        private
+
+        def check_top_level(node)
+          return unless top_level_definition?(node)
+          return if allowed_class?(node)
+
+          @top_level_definitions << node
+          return unless @top_level_definitions.length > 1
+
+          add_offense(range_between(node.source_range.begin_pos, node.loc.name.end_pos))
+        end
+
+        def top_level_definition?(node)
+          if node.parent&.begin_type?
+            node.parent.root?
+          else
+            node.root?
+          end
+        end
+
+        def allowed_class?(node)
+          allowed_classes.include?(node.identifier.short_name)
+        end
+
+        def allowed_classes
+          @allowed_classes ||= cop_config.fetch('AllowedClasses', []).map(&:intern)
+        end
+      end
+    end
+  end
+end

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

@@ -3,9 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of if/then/else/end constructs on a single line.
-      # `AlwaysCorrectToMultiline` config option can be set to true to autocorrect all offenses to
-      # multi-line constructs. When `AlwaysCorrectToMultiline` is false (default case) the
+      # Checks for uses of `if/then/else/end` constructs on a single line.
+      # A ternary operator (`?:`) or multi-line `if` is more readable.
+      # `AlwaysCorrectToMultiline` config option can be set to `true` to autocorrect all offenses to
+      # multi-line constructs. When `AlwaysCorrectToMultiline` is `false` (default case) the
       # autocorrect will first try converting them to ternary operators.
       #
       # @example
@@ -55,19 +56,21 @@ module RuboCop
         include OnNormalIfUnless
         extend AutoCorrector
 
-        MSG = 'Favor the ternary operator (`?:`) or multi-line constructs ' \
-              'over single-line `%<keyword>s/then/else/end` constructs.'
+        MSG_SUFFIX = 'over single-line `%<keyword>s/then/else/end` constructs.'
+        MSG_TERNARY = "Favor the ternary operator (`?:`) #{MSG_SUFFIX}"
+        MSG_MULTILINE = "Favor multi-line `%<keyword>s` #{MSG_SUFFIX}"
 
         def on_normal_if_unless(node)
           return unless node.single_line?
           return unless node.else_branch
           return if node.elsif? || node.if_branch&.begin_type?
 
-          message = message(node)
-          add_offense(node, message: message) do |corrector|
+          multiline = multiline?(node)
+
+          add_offense(node, message: message(node, multiline)) do |corrector|
             next if part_of_ignored_node?(node)
 
-            autocorrect(corrector, node)
+            autocorrect(corrector, node, multiline)
 
             ignore_node(node)
           end
@@ -75,12 +78,18 @@ module RuboCop
 
         private
 
-        def message(node)
-          format(MSG, keyword: node.keyword)
+        def multiline?(node)
+          always_multiline? || cannot_replace_to_ternary?(node)
+        end
+
+        def message(node, multiline)
+          template = multiline ? MSG_MULTILINE : MSG_TERNARY
+
+          format(template, keyword: node.keyword)
         end
 
-        def autocorrect(corrector, node)
-          if always_multiline? || cannot_replace_to_ternary?(node)
+        def autocorrect(corrector, node, multiline)
+          if multiline
             IfThenCorrector.new(node, indentation: configured_indentation_width).call(corrector)
           else
             corrector.replace(node, ternary_correction(node))

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

@@ -26,9 +26,10 @@ module RuboCop
           splat kwsplat forwarded_args forwarded_restarg forwarded_kwrestarg block_pass
         ].freeze
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return unless (dot = node.loc.dot)
+          return if unary_method_no_operator?(node)
           return if node.receiver.const_type? || !node.arguments.one?
 
           return unless (rhs = node.first_argument)
@@ -43,10 +44,18 @@ module RuboCop
             corrector.insert_after(selector, ' ') if insert_space_after?(node)
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
+        # `foo.~@` and `foo.!@` call the method `~` and `!` respectively. While those
+        # are operator methods, we don't want to actually consider them as such.
+        def unary_method_no_operator?(node)
+          return false unless node.nonmutating_unary_operator_method?
+
+          node.method_name.to_s != node.selector.source
+        end
+
         # Checks for an acceptable case of `foo.+(bar).baz`.
         def method_call_with_parenthesized_arg?(argument)
           return false unless argument.parent.parent&.send_type?

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

@@ -4,6 +4,10 @@ module RuboCop
   module Cop
     module Style
       # Checks for simple usages of parallel assignment.
+      # Parallel assignment is less readable than individual
+      # assignments and makes it harder to follow what each
+      # variable is being set to.
+      #
       # This will only complain when the number of variables
       # being assigned matched the number of assigning variables.
       #
@@ -14,7 +18,7 @@ module RuboCop
       #
       #   # good
       #   one, two = *foo
-      #   a, b = foo()
+      #   a, b = foo
       #   a, b = b, a
       #
       #   a = 1
@@ -34,7 +38,7 @@ module RuboCop
           rhs_elements = Array(rhs).compact # edge case for one constant
 
           return if allowed_lhs?(node.assignments) || allowed_rhs?(rhs) ||
-                    allowed_masign?(node.assignments, rhs_elements)
+                    allowed_masign?(node.assignments, rhs_elements) || contains_heredoc?(rhs)
 
           range = node.source_range.begin.join(rhs.source_range.end)
 
@@ -73,6 +77,13 @@ module RuboCop
           !node.array_type? || elements.any?(&:splat_type?)
         end
 
+        # Autocorrection splits the assignment into single assignments on
+        # consecutive lines, which would put following assignments into the
+        # heredoc body unless the heredoc bodies were moved along.
+        def contains_heredoc?(node)
+          node.each_descendant(:any_str).any?(&:heredoc?)
+        end
+
         def assignment_corrector(node, rhs, order)
           if node.parent&.rescue_type?
             _assignment, modifier = *node.parent
@@ -223,7 +234,7 @@ module RuboCop
             # __FILE__ is treated as a StrNode but has no begin
             if node.str_type? && loc.respond_to?(:begin) && loc.begin.nil?
               "'#{node.source}'"
-            elsif node.sym_type? && loc.begin.nil?
+            elsif node.sym_type? && !node.loc?(:begin)
               ":#{node.source}"
             else
               node.source

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

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for consecutive calls to `select`/`filter`/`find_all` and `reject`
+      # on the same receiver with the same block body, where `partition` could be
+      # used instead. Also detects two `select` or two `reject` calls where one
+      # block negates the other with `!`. Using `partition` reduces two collection
+      # traversals to one.
+      #
+      # @safety
+      #   This cop is unsafe because:
+      #
+      #   * `Hash#select` and `Hash#reject` return hashes, but `Hash#partition`
+      #     returns nested arrays.
+      #   * When the receiver has side effects, calling it once (with `partition`)
+      #     versus twice (with `select` + `reject`) may produce different results.
+      #   * Custom classes may override `select`/`reject` without providing a
+      #     compatible `partition` method.
+      #
+      # @example
+      #   # bad
+      #   positives = array.select { |x| x > 0 }
+      #   negatives = array.reject { |x| x > 0 }
+      #
+      #   # bad
+      #   positives = array.filter { |x| x > 0 }
+      #   negatives = array.reject { |x| x > 0 }
+      #
+      #   # bad
+      #   negatives = array.reject { |x| x > 0 }
+      #   positives = array.select { |x| x > 0 }
+      #
+      #   # bad
+      #   positives = array.select(&:positive?)
+      #   negatives = array.reject(&:positive?)
+      #
+      #   # bad
+      #   positives = array.select(&:positive?)
+      #   negatives = array.reject { |x| x.positive? }
+      #
+      #   # bad
+      #   positives = array.select { |x| x.positive? }
+      #   non_positives = array.select { |x| !x.positive? }
+      #
+      #   # good
+      #   positives, negatives = array.partition { |x| x > 0 }
+      #
+      #   # good
+      #   positives, non_positives = array.partition { |x| x.positive? }
+      #
+      #   # good
+      #   positives, negatives = array.partition(&:positive?)
+      #
+      class PartitionInsteadOfDoubleSelect < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `partition` instead of consecutive `%<first>s` and `%<second>s` calls.'
+
+        SELECT_METHODS = %i[select filter find_all].freeze
+        CANDIDATE_METHODS = (SELECT_METHODS + %i[reject]).to_set.freeze
+        RESTRICT_ON_SEND = (SELECT_METHODS + %i[reject]).freeze
+
+        # @!method symbol_proc_method?(node)
+        def_node_matcher :symbol_proc_method?, <<~PATTERN
+          (block _ (args (arg _name)) (send (lvar _name) $_method_name))
+        PATTERN
+
+        def on_block(node)
+          return unless CANDIDATE_METHODS.include?(node.method_name)
+
+          find_and_register_offense(node)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_send(node)
+          return unless node.last_argument&.block_pass_type?
+
+          find_and_register_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def find_and_register_offense(node)
+          container = node_container(node)
+          return unless container
+
+          sibling_container = container.left_sibling
+          sibling = find_matching_candidate(node, sibling_container)
+          return unless sibling
+
+          register_offense(node, sibling, container, sibling_container)
+        end
+
+        def node_container(node)
+          parent = node.parent
+          if parent&.begin_type?
+            node
+          elsif parent&.assignment? && parent.parent&.begin_type?
+            parent
+          end
+        end
+
+        def find_matching_candidate(node, sibling_container)
+          return unless sibling_container
+
+          sibling = extract_candidate(sibling_container)
+          return unless sibling
+          return unless node.receiver == sibling.receiver
+          return unless matching_pair?(node, sibling)
+
+          sibling
+        end
+
+        def matching_pair?(node, sibling)
+          (complementary_pair?(node, sibling) && equivalent_predicate?(node, sibling)) ||
+            (node.method?(sibling.method_name) && negated_predicate?(node, sibling))
+        end
+
+        def extract_candidate(container)
+          extract_block(container) || extract_block_pass_send(container)
+        end
+
+        def extract_block(container)
+          if container.any_block_type?
+            container
+          elsif container.assignment?
+            rhs = container.children.last
+            rhs if rhs&.any_block_type?
+          end
+        end
+
+        def extract_block_pass_send(container)
+          node = container.assignment? ? container.children.last : container
+          return unless node&.type?(:call)
+          return unless node.last_argument&.block_pass_type?
+
+          node
+        end
+
+        def complementary_pair?(node1, node2)
+          m1 = node1.method_name
+          m2 = node2.method_name
+          (SELECT_METHODS.include?(m1) && m2 == :reject) ||
+            (m1 == :reject && SELECT_METHODS.include?(m2))
+        end
+
+        def equivalent_predicate?(node1, node2)
+          if node1.any_block_type? && node2.any_block_type?
+            same_block_contents?(node1, node2)
+          elsif node1.any_block_type?
+            block_matches_block_pass?(node1, node2)
+          elsif node2.any_block_type?
+            block_matches_block_pass?(node2, node1)
+          else
+            node1.last_argument == node2.last_argument
+          end
+        end
+
+        def same_block_contents?(block1, block2)
+          return false unless block1.type == block2.type
+
+          if block1.block_type?
+            block1.arguments == block2.arguments &&
+              block1.body == block2.body
+          else
+            block1.body == block2.body
+          end
+        end
+
+        def block_matches_block_pass?(block_node, send_node)
+          method_name = symbol_proc_method?(block_node)
+          return false unless method_name
+
+          sym_node = send_node.last_argument.children.first
+          sym_node.sym_type? && sym_node.children.first == method_name
+        end
+
+        def negated_predicate?(node1, node2)
+          return false unless node1.any_block_type? && node2.any_block_type?
+          return false unless node1.type == node2.type
+          return false if node1.block_type? && node1.arguments != node2.arguments
+
+          negated_body?(node1.body, node2.body) || negated_body?(node2.body, node1.body)
+        end
+
+        def negated_body?(body1, body2)
+          body1&.send_type? && body1.method?(:!) && body1.receiver == body2
+        end
+
+        def register_offense(node, sibling, container, sibling_container)
+          message = format(MSG, first: sibling.method_name, second: node.method_name)
+
+          add_offense(container, message: message) do |corrector|
+            next unless both_lvasgn?(container, sibling_container)
+
+            autocorrect(corrector, node, sibling, container, sibling_container)
+          end
+        end
+
+        def both_lvasgn?(container, sibling_container)
+          container.lvasgn_type? && sibling_container.lvasgn_type?
+        end
+
+        def autocorrect(corrector, node, sibling, container, sibling_container)
+          if complementary_pair?(node, sibling)
+            select_var, reject_var =
+              complementary_variable_order(sibling, container, sibling_container)
+            partition_node = select_node_for(sibling, container)
+          else
+            select_var, reject_var, partition_node =
+              negation_partition_args(node, sibling, container, sibling_container)
+          end
+
+          partition_call = build_partition_call(partition_node)
+          replacement = "#{select_var}, #{reject_var} = #{partition_call}"
+
+          corrector.replace(sibling_container, replacement)
+          range = range_by_whole_lines(container.source_range, include_final_newline: true)
+          corrector.remove(range)
+        end
+
+        def complementary_variable_order(sibling, container, sibling_container)
+          if SELECT_METHODS.include?(sibling.method_name)
+            [sibling_container.children.first, container.children.first]
+          else
+            [container.children.first, sibling_container.children.first]
+          end
+        end
+
+        def negation_partition_args(node, sibling, container, sibling_container)
+          node_is_negated = negated_body?(node.body, sibling.body)
+          is_select = SELECT_METHODS.include?(node.method_name)
+          # For select: non-negated is truthy (first). For reject: negated is truthy (first).
+          node_is_truthy = is_select != node_is_negated
+          partition_node = node_is_negated ? sibling : node
+
+          if node_is_truthy
+            [container.children.first, sibling_container.children.first, partition_node]
+          else
+            [sibling_container.children.first, container.children.first, partition_node]
+          end
+        end
+
+        def select_node_for(sibling, container)
+          if SELECT_METHODS.include?(sibling.method_name)
+            sibling
+          else
+            container.children.last
+          end
+        end
+
+        def build_partition_call(node)
+          source = node.source
+          send_node = node.any_block_type? ? node.send_node : node
+          selector = send_node.loc.selector
+          offset = node.source_range.begin_pos
+          method_start = selector.begin_pos - offset
+          method_end = selector.end_pos - offset
+
+          "#{source[0...method_start]}partition#{source[method_end..]}"
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Enforces the consistent usage of `%`-literal delimiters.
+      # Using consistent delimiters across the codebase reduces
+      # cognitive load when reading `%`-literals.
       #
       # Specify the 'default' key to set all preferred delimiters at once. You
       # can continue to specify individual preferred delimiters to override the

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for uses of `any?`, `all?`, `none?`, or `one?` with a block
+      # containing only an `is_a?`, `kind_of?`, or `instance_of?` check, and
+      # suggests using the predicate method with the class argument directly.
+      #
+      # @safety
+      #   This cop is unsafe because `instance_of?` checks for an exact class
+      #   match, while the pattern argument uses `===` which also matches
+      #   subclasses. For `is_a?` and `kind_of?`, the behavior is equivalent.
+      #
+      # @example
+      #   # bad
+      #   array.any? { |x| x.is_a?(Integer) }
+      #   array.all? { |x| x.kind_of?(String) }
+      #   array.none? { |x| x.is_a?(Float) }
+      #   array.one? { |x| x.instance_of?(Symbol) }
+      #
+      #   # good
+      #   array.any?(Integer)
+      #   array.all?(String)
+      #   array.none?(Float)
+      #   array.one?(Symbol)
+      class PredicateWithKind < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Prefer `%<replacement>s` to `%<original>s` with a kind check.'
+        RESTRICT_ON_SEND = %i[any? all? none? one?].freeze
+        KIND_METHODS = %i[is_a? kind_of? instance_of?].to_set.freeze
+
+        # @!method kind_check?(node)
+        def_node_matcher :kind_check?, <<~PATTERN
+          {
+            (block call (args (arg $_)) $(send (lvar _) %KIND_METHODS _))
+            (numblock call $1 $(send (lvar _) %KIND_METHODS _))
+            (itblock call $_ $(send (lvar _) %KIND_METHODS _))
+          }
+        PATTERN
+
+        # @!method kind_call?(node, name)
+        def_node_matcher :kind_call?, <<~PATTERN
+          (send (lvar %1) %KIND_METHODS _)
+        PATTERN
+
+        def on_send(node)
+          return unless (block_node = node.block_node)
+          return if block_node.body&.begin_type?
+          return unless (kind_check_node = extract_send_node(block_node))
+
+          klass = kind_check_node.first_argument
+          replacement = "#{node.method_name}(#{klass.source})"
+
+          register_offense(node, block_node, klass, replacement)
+        end
+        alias on_csend on_send
+
+        private
+
+        def extract_send_node(block_node)
+          return unless (block_arg_name, kind_check_node = kind_check?(block_node))
+
+          block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+          block_arg_name = :it if block_node.type?(:itblock)
+
+          kind_check_node if kind_call?(kind_check_node, block_arg_name)
+        end
+
+        def register_offense(node, block_node, klass, replacement)
+          original = "#{node.method_name} { ... }"
+          message = format(MSG, replacement: replacement, original: original)
+
+          add_offense(block_node, message: message) do |corrector|
+            range = range_between(node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+            corrector.replace(range, "#{node.method_name}(#{klass.source})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,22 +14,22 @@ module RuboCop
       #   is a `Hash` or responds to the replacement methods.
       #
       # @example EnforcedStyle: short (default)
-      #  # bad
-      #  Hash#has_key?
-      #  Hash#has_value?
+      #   # bad
+      #   Hash#has_key?
+      #   Hash#has_value?
       #
-      #  # good
-      #  Hash#key?
-      #  Hash#value?
+      #   # good
+      #   Hash#key?
+      #   Hash#value?
       #
       # @example EnforcedStyle: verbose
-      #  # bad
-      #  Hash#key?
-      #  Hash#value?
+      #   # bad
+      #   Hash#key?
+      #   Hash#value?
       #
-      #  # good
-      #  Hash#has_key?
-      #  Hash#has_value?
+      #   # good
+      #   Hash#has_key?
+      #   Hash#has_value?
       class PreferredHashMethods < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of Proc.new where Kernel#proc
-      # would be more appropriate.
+      # Checks for uses of `Proc.new` where `Kernel#proc`
+      # would be more appropriate. `proc` is the shorter and
+      # more idiomatic way to create procs in Ruby.
       #
       # @example
       #   # bad

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

@@ -51,7 +51,7 @@ module RuboCop
         EXPLODED_MSG = 'Provide an exception class and message as arguments to `%<method>s`.'
         COMPACT_MSG = 'Provide an exception object as an argument to `%<method>s`.'
         ACCEPTABLE_ARG_TYPES = %i[
-          hash forwarded_restarg splat forwarded_restarg forwarded_args
+          hash forwarded_restarg splat forwarded_kwrestarg forwarded_args
         ].freeze
 
         RESTRICT_ON_SEND = %i[raise fail].freeze