rubocop 1.75.4 → 1.75.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fc4cebf1565ee3ced4efc79eb1012c0750f797f0ba74f94620ff50ff1d7be8e
-  data.tar.gz: b1e53688b07611ebec3ebc028022f71314960573cc421cfdd1b6c6b831008abf
+  metadata.gz: 31a9b16f521cb4dd8d22db58d5473cd527162b65934d8e210993f7c435a85d26
+  data.tar.gz: 57af5692e8b85aca41224e621a0ba6b54001944a6625edef169a78278066a532
 SHA512:
-  metadata.gz: b124c47ddee3e947bbcda187086ae1a8bf45317702d6ab0bc43f7888b90c8d560c12f61ae6fc4890bf5fec29016d88678cbc08db84e9dad5ee3ec242c8e03884
-  data.tar.gz: fcc14e85af8aac9186971fa21371743f29221c8e694c7cf17b44762d628c7246d720b3e241f006286a43f3523e6ab9e587e0c2f0aecb5d34fe849375ca7ad183
+  metadata.gz: ef0ab376b3993e9ad1961560911ed5b5e2abf069a2b9acd0187e3d31c03f853a520646f2c421813bc3c03aedd74004dcf057cbadecad0ea86acafbd6670c8e46
+  data.tar.gz: b76bd8b4d7492577429bab8abd02ebcf7f2d9d2f83066e81c48b060abcaad68a2660b064c1f5b0b9c42bc80cc78ce15cd6e10ace393cd636310055515af925db

data/config/default.yml

@@ -3702,7 +3702,9 @@ Style/CommentedKeyword:
 Style/ComparableBetween:
   Description: 'Enforces the use of `Comparable#between?` instead of logical comparison.'
   Enabled: pending
+  Safe: false
   VersionAdded: '1.74'
+  VersionChanged: '1.75'
   StyleGuide: '#ranges-or-between'
 
 Style/ComparableClamp:

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -50,7 +50,7 @@ module RuboCop
 
       def disable_offense(offense_range)
         unbreakable_range = multiline_ranges(offense_range)&.find do |range|
-          range_overlaps_offense?(offense_range, range)
+          eol_comment_would_be_inside_literal?(offense_range, range)
         end
 
         if unbreakable_range
@@ -75,18 +75,22 @@ module RuboCop
       end
 
       def disable_offense_with_eol_or_surround_comment(range)
-        eol_comment = " # rubocop:todo #{cop_name}"
-        needed_line_length = (range.source_line + eol_comment).length
-
-        if needed_line_length <= max_line_length
-          disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
-        else
+        if line_with_eol_comment_too_long?(range)
           disable_offense_before_and_after(range_by_lines(range))
+        else
+          disable_offense_at_end_of_line(range_of_first_line(range))
         end
       end
 
-      def range_overlaps_offense?(offense_range, range)
-        offense_range.begin_pos > range.begin_pos && range.overlaps?(offense_range)
+      def eol_comment_would_be_inside_literal?(offense_range, literal_range)
+        return true if line_with_eol_comment_too_long?(offense_range)
+
+        offense_line = offense_range.line
+        offense_line >= literal_range.first_line && offense_line < literal_range.last_line
+      end
+
+      def line_with_eol_comment_too_long?(range)
+        (range.source_line + eol_comment).length > max_line_length
       end
 
       def surrounding_heredoc?(node)
@@ -132,10 +136,14 @@ module RuboCop
         config.for_cop('Layout/LineLength')['Max'] || 120
       end
 
-      def disable_offense_at_end_of_line(range, eol_comment)
+      def disable_offense_at_end_of_line(range)
         Corrector.new(range).insert_after(range, eol_comment)
       end
 
+      def eol_comment
+        " # rubocop:todo #{cop_name}"
+      end
+
       def disable_offense_before_and_after(range_by_lines)
         range_with_newline = range_by_lines.resize(range_by_lines.size + 1)
         leading_whitespace = range_by_lines.source_line[/^\s*/]

data/lib/rubocop/cop/gemspec/duplicated_assignment.rb

@@ -6,10 +6,11 @@ module RuboCop
       # An attribute assignment method calls should be listed only once
       # in a gemspec.
       #
-      # Assigning to an attribute with the same name using `spec.foo =` will be
-      # an unintended usage. On the other hand, duplication of methods such
-      # as `spec.requirements`, `spec.add_runtime_dependency`, and others are
-      # permitted because it is the intended use of appending values.
+      # Assigning to an attribute with the same name using `spec.foo =` or
+      # `spec.attribute#[]=` will be an unintended usage. On the other hand,
+      # duplication of methods such # as `spec.requirements`,
+      # `spec.add_runtime_dependency`, and others are permitted because it is
+      # the intended use of appending values.
       #
       # @example
       #   # bad
@@ -34,6 +35,18 @@ module RuboCop
       #     spec.add_dependency('parallel', '~> 1.10')
       #     spec.add_dependency('parser', '>= 2.3.3.1', '< 3.0')
       #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata["key"] = "value"
+      #     spec.metadata["key"] = "value"
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata["key"] = "value"
+      #   end
+      #
       class DuplicatedAssignment < Base
         include RangeHelp
         include GemspecHelp
@@ -47,9 +60,26 @@ module RuboCop
             (lvar #match_block_variable_name?) _ ...)
         PATTERN
 
+        # @!method indexed_assignment_method_declarations(node)
+        def_node_search :indexed_assignment_method_declarations, <<~PATTERN
+          (send
+            (send (lvar #match_block_variable_name?) _)
+            :[]=
+            literal?
+            _
+          )
+        PATTERN
+
         def on_new_investigation
           return if processed_source.blank?
 
+          process_assignment_method_nodes
+          process_indexed_assignment_method_nodes
+        end
+
+        private
+
+        def process_assignment_method_nodes
           duplicated_assignment_method_nodes.each do |nodes|
             nodes[1..].each do |node|
               register_offense(node, node.method_name, nodes.first.first_line)
@@ -57,7 +87,14 @@ module RuboCop
           end
         end
 
-        private
+        def process_indexed_assignment_method_nodes
+          duplicated_indexed_assignment_method_nodes.each do |nodes|
+            nodes[1..].each do |node|
+              assignment = "#{node.children.first.method_name}[#{node.first_argument.source}]="
+              register_offense(node, assignment, nodes.first.first_line)
+            end
+          end
+        end
 
         def match_block_variable_name?(receiver_name)
           gem_specification(processed_source.ast) do |block_variable_name|
@@ -73,6 +110,13 @@ module RuboCop
             .select { |nodes| nodes.size > 1 }
         end
 
+        def duplicated_indexed_assignment_method_nodes
+          indexed_assignment_method_declarations(processed_source.ast)
+            .group_by { |node| [node.children.first.method_name, node.first_argument] }
+            .values
+            .select { |nodes| nodes.size > 1 }
+        end
+
         def register_offense(node, assignment, line_of_first_occurrence)
           line_range = node.loc.column...node.loc.last_column
           offense_location = source_range(processed_source.buffer, node.first_line, line_range)

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

@@ -22,6 +22,11 @@ module RuboCop
       # * Private attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
       # * Private instance methods
       #
+      # NOTE: Simply enabling the cop with `Enabled: true` will not use
+      # the example order shown below.
+      # To enforce the order of macros like `attr_reader`,
+      # you must define both `ExpectedOrder` *and* `Categories`.
+      #
       # You can configure the following order:
       #
       # [source,yaml]
@@ -68,6 +73,36 @@ module RuboCop
       #        - extend
       # ----
       #
+      # If you only set `ExpectedOrder`
+      # without defining `Categories`,
+      # macros such as `attr_reader` or `has_many`
+      # will not be recognized as part of a category, and their order will not be validated.
+      # For example, the following will NOT raise any offenses, even if the order is incorrect:
+      #
+      # [source,yaml]
+      # ----
+      # Layout/ClassStructure:
+      #   Enabled: true
+      #   ExpectedOrder:
+      #     - public_attribute_macros
+      #     - initializer
+      # ----
+      #
+      # To make it work as expected, you must also specify `Categories` like this:
+      #
+      # [source,yaml]
+      # ----
+      # Layout/ClassStructure:
+      #   ExpectedOrder:
+      #     - public_attribute_macros
+      #     - initializer
+      #   Categories:
+      #     attribute_macros:
+      #       - attr_reader
+      #       - attr_writer
+      #       - attr_accessor
+      # ----
+      #
       # @safety
       #   Autocorrection is unsafe because class methods and module inclusion
       #   can behave differently, based on which methods or constants have

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

@@ -116,7 +116,7 @@ module RuboCop
         def allowed_only_before_style?(node)
           if node.special_modifier?
             return true if processed_source[node.last_line] == 'end'
-            return false if next_line_empty?(node.last_line)
+            return false if next_line_empty_and_exists?(node.last_line)
           end
 
           previous_line_empty?(node.first_line)
@@ -129,7 +129,7 @@ module RuboCop
           when :around
             corrector.insert_after(line, "\n") unless next_line_empty?(node.last_line)
           when :only_before
-            if next_line_empty?(node.last_line)
+            if next_line_empty_and_exists?(node.last_line)
               range = next_empty_line_range(node)
 
               corrector.remove(range)
@@ -154,6 +154,10 @@ module RuboCop
           body_end?(last_send_line) || next_line.blank?
         end
 
+        def next_line_empty_and_exists?(last_send_line)
+          next_line_empty?(last_send_line) && last_send_line.next != processed_source.lines.size
+        end
+
         def empty_lines_around?(node)
           previous_line_empty?(node.first_line) && next_line_empty?(node.last_line)
         end

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

@@ -155,7 +155,7 @@ module RuboCop
         def on_send(node)
           return unless should_check?(node)
           return if same_line?(node, node.first_argument)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation? &&
+          return if enforce_first_argument_with_fixed_indentation? &&
                     !enable_layout_first_method_argument_line_break?
 
           indent = base_indentation(node) + configured_indentation_width

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

@@ -250,7 +250,7 @@ module RuboCop
           reset!
 
           alignment_for(first_pair).each do |alignment|
-            delta = alignment.deltas_for_first_pair(first_pair, node)
+            delta = alignment.deltas_for_first_pair(first_pair)
             check_delta delta, node: first_pair, alignment: alignment
           end
 

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

@@ -58,6 +58,12 @@ module RuboCop
       #   attr_reader :name #: String
       #   attr_reader :age  #: Integer?
       #
+      #   #: (
+      #   #|   Integer,
+      #   #|   String
+      #   #| ) -> void
+      #   def foo; end
+      #
       # @example AllowRBSInlineAnnotation: true
       #
       #   # good
@@ -67,6 +73,12 @@ module RuboCop
       #   attr_reader :name #: String
       #   attr_reader :age  #: Integer?
       #
+      #   #: (
+      #   #|   Integer,
+      #   #|   String
+      #   #| ) -> void
+      #   def foo; end
+      #
       # @example AllowSteepAnnotation: false (default)
       #
       #   # bad
@@ -175,7 +187,7 @@ module RuboCop
         end
 
         def rbs_inline_annotation?(comment)
-          allow_rbs_inline_annotation? && comment.text.start_with?(/#:|#\[.+\]/)
+          allow_rbs_inline_annotation? && comment.text.start_with?(/#:|#\[.+\]|#\|/)
         end
 
         def allow_steep_annotation?

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

@@ -23,6 +23,16 @@ module RuboCop
         def kind(token)
           'semicolon' if token.semicolon?
         end
+
+        def space_missing?(token1, token2)
+          super && !semicolon_sequence?(token1, token2)
+        end
+
+        private
+
+        def semicolon_sequence?(token, next_token)
+          token.semicolon? && next_token.semicolon?
+        end
       end
     end
   end

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

@@ -22,51 +22,25 @@ module RuboCop
         RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
-          return unless (first_argument = node.first_argument)
-
-          begin_pos = first_argument.source_range.begin_pos
-          return unless (range = offense_range(node, begin_pos))
-
-          register_offense(range)
-        end
-
-        private
-
-        def offense_range(node, begin_pos)
           receiver_end_pos = node.receiver.source_range.end_pos
           selector_begin_pos = node.loc.selector.begin_pos
           return if receiver_end_pos >= selector_begin_pos
           return if dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
 
-          if reference_variable_with_brackets?(node)
-            range_between(receiver_end_pos, selector_begin_pos)
-          elsif node.method?(:[]=)
-            offense_range_for_assignment(node, begin_pos)
+          range = range_between(receiver_end_pos, selector_begin_pos)
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
           end
         end
 
+        private
+
         def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
           return false unless node.loc.respond_to?(:dot) && (dot = node.loc.dot)
 
           dot.begin_pos == receiver_end_pos && dot.end_pos == selector_begin_pos
         end
-
-        def offense_range_for_assignment(node, begin_pos)
-          end_pos = node.receiver.source_range.end_pos
-
-          return if begin_pos - end_pos == 1 ||
-                    (range = range_between(end_pos, begin_pos - 1)).source.start_with?('[')
-
-          range
-        end
-
-        def register_offense(range)
-          add_offense(range) { |corrector| corrector.remove(range) }
-        end
-
-        def reference_variable_with_brackets?(node)
-          node.receiver&.variable? && node.method?(:[]) && node.arguments.size == 1
-        end
       end
     end
   end

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

@@ -6,6 +6,8 @@ module RuboCop
       # Checks that brackets used for array literals have or don't have
       # surrounding space depending on configuration.
       #
+      # Array pattern matching is handled in the same way.
+      #
       # @example EnforcedStyle: no_space (default)
       #   # The `no_space` style enforces that array literals have
       #   # no surrounding space.
@@ -82,9 +84,10 @@ module RuboCop
         EMPTY_MSG = '%<command>s space inside empty array brackets.'
 
         def on_array(node)
-          return unless node.square_brackets?
+          return if node.array_type? && !node.square_brackets?
 
           tokens, left, right = array_brackets(node)
+          return unless left && right
 
           if empty_brackets?(left, right, tokens: tokens)
             return empty_offenses(node, left, right, EMPTY_MSG)
@@ -95,6 +98,7 @@ module RuboCop
 
           issue_offenses(node, left, right, start_ok, end_ok)
         end
+        alias on_array_pattern on_array
 
         private
 

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

@@ -6,6 +6,8 @@ module RuboCop
       # Checks that braces used for hash literals have or don't have
       # surrounding space depending on configuration.
       #
+      # Hash pattern matching is handled in the same way.
+      #
       # @example EnforcedStyle: space (default)
       #   # The `space` style enforces that hash literals have
       #   # surrounding space.
@@ -87,6 +89,7 @@ module RuboCop
           check(tokens[-2], tokens[-1]) if tokens.size > 2
           check_whitespace_only_hash(node) if enforce_no_space_style_for_empty_braces?
         end
+        alias on_hash_pattern on_hash
 
         private
 

data/lib/rubocop/cop/lint/array_literal_in_regexp.rb

@@ -51,10 +51,9 @@ module RuboCop
                       'in a regexp.'
 
         def on_interpolation(begin_node)
-          final_node = begin_node.children.last
-
-          return unless begin_node.parent.regexp_type?
+          return unless (final_node = begin_node.children.last)
           return unless final_node.array_type?
+          return unless begin_node.parent.regexp_type?
 
           if array_of_literal_values?(final_node)
             register_array_of_literal_values(begin_node, final_node)

data/lib/rubocop/cop/lint/deprecated_class_methods.rb

@@ -43,7 +43,7 @@ module RuboCop
           dup: 'to_h',
           exists?: 'exist?',
           gethostbyaddr: 'Addrinfo#getnameinfo',
-          gethostbyname: 'Addrinfo#getaddrinfo',
+          gethostbyname: 'Addrinfo.getaddrinfo',
           iterator?: 'block_given?'
         }.freeze
 

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -39,9 +39,52 @@ module RuboCop
       #   end
       #
       #   alias bar foo
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #
+      #   # good
+      #   def foo
+      #     1
+      #   end
+      #
+      #   delegate :foo, to: :bar
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #
+      #   # bad
+      #   def foo
+      #     1
+      #   end
+      #
+      #   delegate :foo, to: :bar
+      #
+      #   # good
+      #   def foo
+      #     1
+      #   end
+      #
+      #   delegate :baz, to: :bar
+      #
+      #   # good - delegate with splat arguments is ignored
+      #   def foo
+      #     1
+      #   end
+      #
+      #   delegate :foo, **options
+      #
+      #   # good - delegate inside a condition is ignored
+      #   def foo
+      #     1
+      #   end
+      #
+      #   if cond
+      #     delegate :foo, to: :bar
+      #   end
+      #
       class DuplicateMethods < Base
         MSG = 'Method `%<method>s` is defined at both %<defined>s and %<current>s.'
-        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr].freeze
+        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr
+                              delegate].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -85,15 +128,28 @@ module RuboCop
           (send nil? :alias_method (sym $_name) _)
         PATTERN
 
+        # @!method delegate_method?(node)
+        def_node_matcher :delegate_method?, <<~PATTERN
+          (send nil? :delegate
+            ({sym str} $_)+
+            (hash <(pair (sym :to) {sym str}) ...>)
+          )
+        PATTERN
+
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
-        def on_send(node)
+
+        def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           if (name = alias_method?(node))
             return if node.ancestors.any?(&:if_type?)
 
             found_instance_method(node, name)
           elsif (attr = node.attribute_accessor?)
             on_attr(node, *attr)
+          elsif active_support_extensions_enabled? && (names = delegate_method?(node))
+            return if node.ancestors.any?(&:if_type?)
+
+            on_delegate(node, names)
           end
         end
 
@@ -118,6 +174,32 @@ module RuboCop
                       current: source_location(node))
         end
 
+        def on_delegate(node, method_names)
+          name_prefix = delegate_prefix(node)
+
+          method_names.each do |name|
+            name = "#{name_prefix}_#{name}" if name_prefix
+
+            found_instance_method(node, name)
+          end
+        end
+
+        def delegate_prefix(node)
+          kwargs_node = node.last_argument
+
+          return unless (prefix = hash_value(kwargs_node, :prefix))
+
+          if prefix.true_type?
+            hash_value(kwargs_node, :to).value
+          elsif prefix.type?(:sym, :str)
+            prefix.value
+          end
+        end
+
+        def hash_value(node, key)
+          node.pairs.find { |pair| pair.key.value == key }&.value
+        end
+
         def found_instance_method(node, name)
           return found_sclass_method(node, name) unless (scope = node.parent_module_name)
 

data/lib/rubocop/cop/lint/float_comparison.rb

@@ -15,6 +15,14 @@ module RuboCop
       #   x == 0.1
       #   x != 0.1
       #
+      #   # bad
+      #   case value
+      #   when 1.0
+      #     foo
+      #   when 2.0
+      #     bar
+      #   end
+      #
       #   # good - using BigDecimal
       #   x.to_d == 0.1.to_d
       #
@@ -32,12 +40,21 @@ module RuboCop
       #   # good - comparing against nil
       #   Float(x, exception: false) == nil
       #
+      #   # good - using epsilon comparison in case expression
+      #   case
+      #   when (value - 1.0).abs < Float::EPSILON
+      #     foo
+      #   when (value - 2.0).abs < Float::EPSILON
+      #     bar
+      #   end
+      #
       #   # Or some other epsilon based type of comparison:
       #   # https://www.embeddeduse.com/2019/08/26/qt-compare-two-floats/
       #
       class FloatComparison < Base
         MSG_EQUALITY = 'Avoid equality comparisons of floats as they are unreliable.'
         MSG_INEQUALITY = 'Avoid inequality comparisons of floats as they are unreliable.'
+        MSG_CASE = 'Avoid float literal comparisons in case statements as they are unreliable.'
 
         EQUALITY_METHODS = %i[== != eql? equal?].freeze
         FLOAT_RETURNING_METHODS = %i[to_f Float fdiv].freeze
@@ -58,6 +75,16 @@ module RuboCop
         end
         alias on_csend on_send
 
+        def on_case(node)
+          node.when_branches.each do |when_branch|
+            when_branch.each_condition do |condition|
+              next if !float?(condition) || literal_safe?(condition)
+
+              add_offense(condition, message: MSG_CASE)
+            end
+          end
+        end
+
         private
 
         def float?(node)

data/lib/rubocop/cop/lint/literal_as_condition.rb

@@ -248,7 +248,7 @@ module RuboCop
             add_offense(cond) do |corrector|
               corrector.replace(node, "else\n  #{node.else_branch.source}")
             end
-          elsif result
+          elsif node.if_branch && result
             add_offense(cond) do |corrector|
               corrector.replace(node, node.if_branch.source)
             end

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -104,6 +104,8 @@ module RuboCop
         end
 
         def chained_assignment?(node)
+          return true if node.lvasgn_type? && node.expression&.send_type?
+
           node.respond_to?(:expression) && node.expression&.lvasgn_type?
         end
 

data/lib/rubocop/cop/lint/void.rb

@@ -128,8 +128,8 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_void_op(node, &block)
-          node = node.children.first while node.begin_type?
-          return unless node.call_type? && OPERATORS.include?(node.method_name)
+          node = node.children.first while node&.begin_type?
+          return unless node&.call_type? && OPERATORS.include?(node.method_name)
           if !UNARY_OPERATORS.include?(node.method_name) && node.loc.dot && node.arguments.none?
             return
           end

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -39,7 +39,7 @@ module RuboCop
       class AbcSize < Base
         include MethodComplexity
 
-        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
+        MSG = 'Assignment Branch Condition size for `%<method>s` is too high. ' \
               '[%<abc_vector>s %<complexity>.4g/%<max>.4g]'
 
         private