rubocop 1.84.2 → 1.86.0

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

@@ -3,7 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for trailing inline comments.
+      # Checks for trailing inline comments. Inline comments can
+      # make lines harder to read, especially when they are long.
+      # Placing comments on their own line above the code they
+      # describe is often clearer.
       #
       # @example
       #

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

@@ -48,8 +48,7 @@ module RuboCop
         private
 
         def allowed_addresses
-          allowed_addresses = cop_config['AllowedAddresses']
-          Array(allowed_addresses).map(&:downcase)
+          @allowed_addresses ||= Array(cop_config['AllowedAddresses']).map(&:downcase).freeze
         end
 
         def potential_ip?(str)

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

@@ -176,7 +176,7 @@ module RuboCop
           if first_non_comment_token
             0...first_non_comment_token.line
           else
-            (0..)
+            0..
           end
         end
 
@@ -299,7 +299,7 @@ module RuboCop
         end
 
         def supported_capitalizations
-          cop_config['SupportedCapitalizations'].map(&:to_sym)
+          @supported_capitalizations ||= cop_config['SupportedCapitalizations'].map(&:to_sym).freeze
         end
       end
     end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `map { |x| x.to_s }.join` and similar calls where the
+      # `map` is redundant because `Array#join` implicitly calls `#to_s` on
+      # each element.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot guarantee that the receiver
+      #   is an `Array` by static analysis. If the receiver does not have
+      #   an `Array#join`-compatible implementation (i.e. one that calls
+      #   `#to_s` on elements), the correction may change behavior.
+      #
+      # @example
+      #   # bad
+      #   array.map(&:to_s).join(', ')
+      #
+      #   # bad
+      #   array.map { |x| x.to_s }.join(', ')
+      #
+      #   # bad
+      #   array.collect(&:to_s).join
+      #
+      #   # good
+      #   array.join(', ')
+      #
+      #   # good
+      #   array.join
+      #
+      class MapJoin < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Remove redundant `%<method>s(&:to_s)` before `join`.'
+        RESTRICT_ON_SEND = %i[join].freeze
+
+        # map(&:to_s).join(...)
+        # @!method map_to_s_join?(node)
+        def_node_matcher :map_to_s_join?, <<~PATTERN
+          (call
+            $(call _ ${:map :collect} (block_pass (sym :to_s)))
+            :join ...)
+        PATTERN
+
+        # map { |x| x.to_s }.join(...)
+        # @!method map_to_s_block_join?(node)
+        def_node_matcher :map_to_s_block_join?, <<~PATTERN
+          (call
+            $(block
+              (call _ ${:map :collect})
+              (args (arg _x))
+              (send (lvar _x) :to_s))
+            :join ...)
+        PATTERN
+
+        # map { _1.to_s }.join(...)
+        # @!method map_to_s_numblock_join?(node)
+        def_node_matcher :map_to_s_numblock_join?, <<~PATTERN
+          (call
+            $(numblock
+              (call _ ${:map :collect})
+              1
+              (send (lvar :_1) :to_s))
+            :join ...)
+        PATTERN
+
+        # map { it.to_s }.join(...)
+        # @!method map_to_s_itblock_join?(node)
+        def_node_matcher :map_to_s_itblock_join?, <<~PATTERN
+          (call
+            $(itblock
+              (call _ ${:map :collect})
+              :it
+              (send (lvar :it) :to_s))
+            :join ...)
+        PATTERN
+
+        def on_send(node)
+          map_to_s_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_block_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_numblock_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_itblock_join?(node) { |m, n| register_offense(node, m, n) }
+        end
+        alias on_csend on_send
+
+        private
+
+        def register_offense(join_node, map_node, method_name)
+          map_send = map_node.any_block_type? ? map_node.send_node : map_node
+          message = format(MSG, method: method_name)
+
+          add_offense(map_send.loc.selector, message: message) do |corrector|
+            remove_map_call(corrector, join_node, map_node, map_send)
+          end
+        end
+
+        def remove_map_call(corrector, join_node, map_node, map_send)
+          receiver = map_send.receiver
+          if receiver
+            corrector.replace(removal_range(receiver, map_node, map_send), '')
+          else
+            corrector.replace(no_receiver_range(map_node, join_node), '')
+          end
+        end
+
+        def removal_range(receiver, map_node, map_send)
+          start_pos = if receiver.last_line < map_send.loc.dot.line
+                        receiver.source_range.end_pos
+                      else
+                        map_send.loc.dot.begin_pos
+                      end
+          range_between(start_pos, map_node.source_range.end_pos)
+        end
+
+        def no_receiver_range(map_node, join_node)
+          range_between(map_node.source_range.begin_pos, join_node.loc.dot.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -33,16 +33,18 @@ module RuboCop
           end
 
           def included_macros_list
-            cop_config.fetch('IncludedMacros', []).map(&:to_sym)
+            @included_macros_list ||= cop_config.fetch('IncludedMacros', []).map(&:to_sym).freeze
           end
 
           def included_macro_patterns
-            cop_config.fetch('IncludedMacroPatterns', [])
+            @included_macro_patterns ||=
+              cop_config.fetch('IncludedMacroPatterns', [])
+                        .map { |pattern| Regexp.new(pattern) }.freeze
           end
 
           def matches_included_macro_pattern?(method_name)
             included_macro_patterns.any? do |pattern|
-              Regexp.new(pattern).match?(method_name.to_s)
+              pattern.match?(method_name.to_s)
             end
           end
 

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of the `then` keyword in multi-line if statements.
+      # Checks for uses of the `then` keyword in multi-line `if` statements.
+      # In multi-line `if` statements, `then` is redundant because the newline
+      # already separates the condition from the body.
       #
       # @example
       #   # bad

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

@@ -125,7 +125,7 @@ module RuboCop
         MSG = 'Freeze mutable objects assigned to constants.'
 
         def on_casgn(node)
-          if node.expression.nil? # This is only the case for `CONST += ...` or similarg66
+          if node.expression.nil? # This is only the case for `CONST += ...` or similar
             parent = node.parent
             return unless parent.or_asgn_type? # We only care about `CONST ||= ...`
 

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

@@ -4,9 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for comparison of something with nil using `==` and
-      # `nil?`.
-      #
-      # Supported styles are: predicate, comparison.
+      # `nil?`. Enforcing a consistent style (either the `nil?`
+      # predicate or `==` comparison) improves readability.
       #
       # @example EnforcedStyle: predicate (default)
       #

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

@@ -43,7 +43,7 @@ module RuboCop
           { ({return next break} nil) (nil) }
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless node.lambda_or_proc?
           return unless nil_return?(node.body)
 

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

@@ -121,17 +121,11 @@ module RuboCop
         end
 
         def autocorrect_comparison(corrector, node)
-          expr = node.source
-
-          new_code = if include_semantic_changes?
-                       expr.sub(/\s*!=\s*nil/, '')
-                     else
-                       expr.sub(/^(\S*)\s*!=\s*nil/, '!\1.nil?')
-                     end
-
-          return if expr == new_code
-
-          corrector.replace(node, new_code)
+          if include_semantic_changes?
+            corrector.replace(node, node.receiver.source)
+          else
+            corrector.replace(node, "!#{node.receiver.source}.nil?")
+          end
         end
 
         def autocorrect_non_nil(corrector, node, inner_node)

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of the keyword `not` instead of `!`.
+      # The `not` keyword has lower precedence than `!`, which can
+      # lead to surprising behavior and often requires parentheses.
       #
       # @example
       #

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for big numeric literals without `_` between groups
-      # of digits in them.
+      # of digits in them. Underscores make large numbers easier to
+      # read by visually separating groups of digits.
       #
       # Additional allowed patterns can be added by adding regexps to
       # the `AllowedPatterns` configuration. All regexps are treated
@@ -116,7 +117,7 @@ module RuboCop
         end
 
         def allowed_numbers
-          cop_config.fetch('AllowedNumbers', []).map(&:to_s)
+          @allowed_numbers ||= cop_config.fetch('AllowedNumbers', []).map(&:to_s).freeze
         end
 
         def allowed_patterns

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

@@ -0,0 +1,95 @@
+# 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
+      #   class Foo
+      #   end
+      #
+      #   class Bar
+      #   end
+      #
+      #   # bad
+      #   class Foo
+      #   end
+      #
+      #   module Bar
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     class Bar
+      #     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

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.
       #

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