rubocop 1.59.0 → 1.60.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 236fd46f4a118eb34ff38fce1a147a116b2d30a7bf849ca809ece40aecabc694
-  data.tar.gz: 550ecc4682d191a6a429a6af299212a42aa459e0aee04d5f7cb6a20ded419ff4
+  metadata.gz: a5baa438e333ac7dbae0d7481f0a512e950f9ef11014f09d78f360d3bc64d528
+  data.tar.gz: bfba21f2555729c81554baad4910a35088fef9ba39538402e54841fdff1c8d8f
 SHA512:
-  metadata.gz: 5c7cfaa0f6573e566bbbac89a993889cd0f0944ab5c012e0286da61021e2d3da6ed51f68fbbf6c71afd4b6d81c577d15228b7a6a2d93aed59d2dfcba61a9be63
-  data.tar.gz: 5cbb4256ff218ab5744fc3065f56061e5b0eab787d21dc30f3ded5972b789ffc2c24cd977fbaf3acbcc84abf36c5e3537a2eeb328dabb3becf29268eccaa81f8
+  metadata.gz: 247eadb99d0c3d9f46067a707a0511433567fea2326ded958381c55cabe9a24ef6c2328e6d4ab901454a6af60cba185d5f87364fc9c1399684bbf3a657ef383b
+  data.tar.gz: 675be6aba0374927f8bf17df0d1dc51d4fc7a05431981d164ae62715fd9008b8ae6208b50f4b509afadb4622a0b19e0bf5d4c650aa203407ece15e9d88ebe031

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-23 Bozhidar Batsov
+Copyright (c) 2012-24 Bozhidar Batsov
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/rubocop/rubocop/master/logo/rubo-logo-horizontal.png" alt="RuboCop Logo"/>
+  <img src="https://raw.githubusercontent.com/rubocop/rubocop/master/logo/rubo-logo-horizontal-white.png" alt="RuboCop Logo"/>
 </p>
 
 ----------
@@ -53,7 +53,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.59', require: false
+gem 'rubocop', '~> 1.60', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.
@@ -248,5 +248,5 @@ RuboCop's changelog is available [here](CHANGELOG.md).
 
 ## Copyright
 
-Copyright (c) 2012-2023 Bozhidar Batsov. See [LICENSE.txt](LICENSE.txt) for
+Copyright (c) 2012-2024 Bozhidar Batsov. See [LICENSE.txt](LICENSE.txt) for
 further details.

data/config/default.yml

@@ -4712,6 +4712,7 @@ Style/OperatorMethodCall:
 
 Style/OptionHash:
   Description: "Don't use option hashes when you can use keyword arguments."
+  StyleGuide: '#keyword-arguments-vs-option-hashes'
   Enabled: false
   VersionAdded: '0.33'
   VersionChanged: '0.34'
@@ -5237,7 +5238,8 @@ Style/SingleLineMethods:
   AllowIfMethodIsEmpty: true
 
 Style/SlicingWithRange:
-  Description: 'Checks array slicing is done with endless ranges when suitable.'
+  Description: 'Checks array slicing is done with redundant, endless, and beginless ranges when suitable.'
+  StyleGuide: '#slicing-with-ranges'
   Enabled: true
   VersionAdded: '0.83'
   Safe: false

data/lib/rubocop/config.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'pathname'
-
 # FIXME: Moving Rails department code to RuboCop Rails will remove
 # the following rubocop:disable comment.
 # rubocop:disable Metrics/ClassLength

data/lib/rubocop/config_loader.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'erb'
-require 'pathname'
 require 'yaml'
 require_relative 'config_finder'
 

data/lib/rubocop/config_validator.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'pathname'
-
 module RuboCop
   # Handles validation of configuration, for example cop names, parameter
   # names, and Ruby versions.

data/lib/rubocop/cop/base.rb

@@ -481,6 +481,12 @@ module RuboCop
           range.end_pos + @current_offset
         )
       end
+
+      # This experimental feature has been under consideration for a while.
+      # @api private
+      def lsp_mode?
+        ARGV.include?('--lsp')
+      end
     end
   end
 end

data/lib/rubocop/cop/exclude_limit.rb

@@ -8,7 +8,7 @@ module RuboCop
     # The parameter name given is transformed into a method name (eg. `Max`
     # becomes `self.max=` and `MinDigits` becomes `self.min_digits=`).
     def exclude_limit(parameter_name, method_name: transform(parameter_name))
-      define_method("#{method_name}=") do |value|
+      define_method(:"#{method_name}=") do |value|
         cfg = config_to_allow_offenses
         cfg[:exclude_limit] ||= {}
         current_max = cfg[:exclude_limit][parameter_name]

data/lib/rubocop/cop/internal_affairs/example_description.rb

@@ -63,10 +63,10 @@ module RuboCop
           expect_correction: EXPECT_CORRECTION_DESCRIPTION_MAPPING
         }.freeze
 
-        # @!method offense_example?(node)
-        def_node_matcher :offense_example?, <<~PATTERN
+        # @!method offense_example(node)
+        def_node_matcher :offense_example, <<~PATTERN
           (block
-            (send _ {:it :specify} $_description)
+            (send _ {:it :specify} $...)
             _args
             `(send nil? %RESTRICT_ON_SEND ...)
           )
@@ -74,7 +74,7 @@ module RuboCop
 
         def on_send(node)
           parent = node.each_ancestor(:block).first
-          return unless parent && (current_description = offense_example?(parent))
+          return unless parent && (current_description = offense_example(parent)&.first)
 
           method_name = node.method_name
           message = format(MSG, method_name: method_name)

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

@@ -83,7 +83,11 @@ module RuboCop
         end
 
         def on_sclass(node)
-          check_other_alignment(node)
+          if node.parent&.assignment?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
         end
 
         def on_module(node)

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

@@ -5,7 +5,10 @@ module RuboCop
     module Layout
       # Checks the indentation of the first element in an array literal
       # where the opening bracket and the first element are on separate lines.
-      # The other elements' indentations are handled by the ArrayAlignment cop.
+      # The other elements' indentations are handled by `Layout/ArrayAlignment` cop.
+      #
+      # This cop will respect `Layout/ArrayAlignment` and will not work when
+      # `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArrayAlignment`.
       #
       # By default, array literals that are arguments in a method call with
       # parentheses, and where the opening square bracket of the array is on the
@@ -93,6 +96,8 @@ module RuboCop
         end
 
         def on_send(node)
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+
           each_argument_node(node, :array) do |array_node, left_parenthesis|
             check(array_node, left_parenthesis)
           end
@@ -174,6 +179,16 @@ module RuboCop
             'where the left bracket is.'
           end
         end
+
+        def enforce_first_argument_with_fixed_indentation?
+          return false unless array_alignment_config['Enabled']
+
+          array_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def array_alignment_config
+          config.for_cop('Layout/ArrayAlignment')
+        end
       end
     end
   end

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

@@ -107,7 +107,7 @@ module RuboCop
           return false unless line.end_with?("\\\n")
 
           # Ensure backslash isn't part of a token spanning to the next line.
-          node.children.none? { |c| c.first_line == line_num && c.multiline? }
+          node.children.none? { |c| (c.first_line...c.last_line).cover?(line_num) && c.multiline? }
         end
 
         def autocorrect(corrector, offense_range, insert_pos, spaces)

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

@@ -85,7 +85,11 @@ module RuboCop
 
         def offense?(node)
           node.multiline? && !too_long?(node) && suitable_as_single_line?(node) &&
-            !configured_to_not_be_inspected?(node)
+            !index_access_call_chained?(node) && !configured_to_not_be_inspected?(node)
+        end
+
+        def index_access_call_chained?(node)
+          node.send_type? && node.method?(:[]) && node.children.first.method?(:[])
         end
 
         def configured_to_not_be_inspected?(node)

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

@@ -41,7 +41,7 @@ module RuboCop
             next unless asgn_node.loc.operator
 
             rhs = asgn_node.to_a.last
-            next if !forbidden_literal?(rhs) || parallel_assignment_with_splat_operator?(rhs)
+            next if !all_literals?(rhs) || parallel_assignment_with_splat_operator?(rhs)
 
             range = offense_range(asgn_node, rhs)
 
@@ -59,10 +59,17 @@ module RuboCop
           node.each_child_node { |child| traverse_node(child, &block) }
         end
 
-        def forbidden_literal?(node)
-          return false if node.dstr_type? || node.xstr_type?
-
-          node.respond_to?(:literal?) && node.literal?
+        def all_literals?(node)
+          case node.type
+          when :dstr, :xstr
+            false
+          when :array
+            node.values.all? { |value| all_literals?(value) }
+          when :hash
+            (node.values + node.keys).all? { |item| all_literals?(item) }
+          else
+            node.respond_to?(:literal?) && node.literal?
+          end
         end
 
         def parallel_assignment_with_splat_operator?(node)

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

@@ -123,6 +123,7 @@ module RuboCop
 
             # Shorthand assignments always use their arguments
             next false if assignment_node.shorthand_asgn?
+            next false unless assignment_node.parent
 
             node_within_block_or_conditional =
               node_within_block_or_conditional?(assignment_node.parent, argument.scope.node)

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

@@ -17,9 +17,12 @@ module RuboCop
         private
 
         def add_offense_from_diagnostic(diagnostic, ruby_version)
-          message =
-            "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
-            'configure using `TargetRubyVersion` parameter, under `AllCops`)'
+          message = if lsp_mode?
+                      diagnostic.message
+                    else
+                      "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
+                        'configure using `TargetRubyVersion` parameter, under `AllCops`)'
+                    end
           add_offense(diagnostic.location, message: message, severity: diagnostic.level)
         end
 

data/lib/rubocop/cop/mixin/configurable_formatting.rb

@@ -18,6 +18,7 @@ module RuboCop
         alternative_styles.each do |alternative|
           return unexpected_style_detected(alternative) if valid_name?(node, name, alternative)
         end
+        unrecognized_style_detected
       end
 
       def valid_name?(node, name, given_style = style)

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -51,21 +51,29 @@ module RuboCop
           [Lint::AmbiguousOperator, Style::ArgumentsForwarding]
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_def(node)
           return if node.arguments.empty?
 
           last_argument = node.last_argument
           return if expected_block_forwarding_style?(node, last_argument)
 
-          register_offense(last_argument, node)
-
+          invalid_syntax = false
           node.each_descendant(:block_pass) do |block_pass_node|
             next if block_pass_node.children.first&.sym_type? ||
                     last_argument.source != block_pass_node.source
 
+            if block_pass_node.each_ancestor(:block, :numblock).any?
+              invalid_syntax = true
+              next
+            end
+
             register_offense(block_pass_node, node)
           end
+
+          register_offense(last_argument, node) unless invalid_syntax
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
         alias on_defs on_def
 
         private

data/lib/rubocop/cop/security/open.rb

@@ -23,6 +23,7 @@ module RuboCop
       #   # bad
       #   open(something)
       #   open("| #{something}")
+      #   open("| foo")
       #   URI.open(something)
       #
       #   # good
@@ -32,7 +33,6 @@ module RuboCop
       #
       #   # good (literal strings)
       #   open("foo.text")
-      #   open("| foo")
       #   URI.open("http://example.com")
       class Open < Base
         MSG = 'The use of `%<receiver>sopen` is a serious security risk.'
@@ -40,7 +40,7 @@ module RuboCop
 
         # @!method open?(node)
         def_node_matcher :open?, <<~PATTERN
-          (send ${nil? (const {nil? cbase} :URI)} :open $!str ...)
+          (send ${nil? (const {nil? cbase} :URI)} :open $_ ...)
         PATTERN
 
         def on_send(node)

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

@@ -104,7 +104,7 @@ module RuboCop
       #   end
       #
       # @example RedundantBlockArgumentNames: ['blk', 'block', 'proc'] (default)
-      #   # bad
+      #   # bad - But it is good with `EnforcedStyle: explicit` set for `Naming/BlockForwarding`.
       #   def foo(&block)
       #     bar(&block)
       #   end
@@ -126,6 +126,7 @@ module RuboCop
         FORWARDING_MSG = 'Use shorthand syntax `...` for arguments forwarding.'
         ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
         KWARGS_MSG = 'Use anonymous keyword arguments forwarding (`**`).'
+        BLOCK_MSG = 'Use anonymous block arguments forwarding (`&`).'
 
         def self.autocorrect_incompatible_with
           [Naming::BlockForwarding]
@@ -171,27 +172,42 @@ module RuboCop
           send_classifications.all? { |_, c, _, _| c == :all }
         end
 
+        # rubocop:disable Metrics/MethodLength
         def add_forward_all_offenses(node, send_classifications, forwardable_args)
-          send_classifications.each do |send_node, _c, forward_rest, _forward_kwrest|
-            register_forward_all_offense(send_node, send_node, forward_rest)
+          _rest_arg, _kwrest_arg, block_arg = *forwardable_args
+          registered_block_arg_offense = false
+
+          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
+            if !forward_rest && !forward_kwrest
+              register_forward_block_arg_offense(!forward_rest, node.arguments, block_arg)
+              register_forward_block_arg_offense(!forward_rest, send_node, forward_block_arg)
+
+              registered_block_arg_offense = true
+              break
+            else
+              register_forward_all_offense(send_node, send_node, forward_rest)
+            end
           end
 
+          return if registered_block_arg_offense
+
           rest_arg, _kwrest_arg, _block_arg = *forwardable_args
           register_forward_all_offense(node, node.arguments, rest_arg)
         end
+        # rubocop:enable Metrics/MethodLength
 
         def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
           return unless use_anonymous_forwarding?
 
           rest_arg, kwrest_arg, _block_arg = *forwardable_args
 
-          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest|
-            if forward_rest
+          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, _forward_block_arg| # rubocop:disable Layout/LineLength
+            if outside_block?(forward_rest)
               register_forward_args_offense(def_node.arguments, rest_arg)
               register_forward_args_offense(send_node, forward_rest)
             end
 
-            if forward_kwrest
+            if outside_block?(forward_kwrest)
               register_forward_kwargs_offense(!forward_rest, def_node.arguments, kwrest_arg)
               register_forward_kwargs_offense(!forward_rest, send_node, forward_kwrest)
             end
@@ -225,10 +241,7 @@ module RuboCop
 
         def classification_and_forwards(def_node, send_node, referenced_lvars, forwardable_args)
           classifier = SendNodeClassifier.new(
-            def_node,
-            send_node,
-            referenced_lvars,
-            forwardable_args,
+            def_node, send_node, referenced_lvars, forwardable_args,
             target_ruby_version: target_ruby_version,
             allow_only_rest_arguments: allow_only_rest_arguments?
           )
@@ -237,7 +250,12 @@ module RuboCop
 
           return unless classification
 
-          [classification, classifier.forwarded_rest_arg, classifier.forwarded_kwrest_arg]
+          [
+            classification,
+            classifier.forwarded_rest_arg,
+            classifier.forwarded_kwrest_arg,
+            classifier.forwarded_block_arg
+          ]
         end
 
         def redundant_named_arg(arg, config_name, keyword)
@@ -250,6 +268,12 @@ module RuboCop
           redundant_arg_names.include?(arg.source) ? arg : nil
         end
 
+        def outside_block?(node)
+          return false unless node
+
+          node.each_ancestor(:block, :numblock).none?
+        end
+
         def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat)
           add_offense(rest_arg_or_splat, message: ARGS_MSG) do |corrector|
             add_parens_if_missing(def_arguments_or_send, corrector)
@@ -266,6 +290,16 @@ module RuboCop
           end
         end
 
+        def register_forward_block_arg_offense(add_parens, def_arguments_or_send, block_arg)
+          return if target_ruby_version <= 3.0 || block_arg.source == '&' || explicit_block_name?
+
+          add_offense(block_arg, message: BLOCK_MSG) do |corrector|
+            add_parens_if_missing(def_arguments_or_send, corrector) if add_parens
+
+            corrector.replace(block_arg, '&')
+          end
+        end
+
         def register_forward_all_offense(def_or_send, send_or_arguments, rest_or_splat)
           arg_range = arguments_range(def_or_send, rest_or_splat)
 
@@ -340,7 +374,7 @@ module RuboCop
           end
 
           def classification
-            return nil unless forwarded_rest_arg || forwarded_kwrest_arg
+            return nil unless forwarded_rest_arg || forwarded_kwrest_arg || forwarded_block_arg
 
             if can_forward_all?
               :all
@@ -424,9 +458,23 @@ module RuboCop
           def no_additional_args?
             forwardable_count = [@rest_arg, @kwrest_arg, @block_arg].compact.size
 
+            return false if missing_rest_arg_or_kwrest_arg?
+
             @def_node.arguments.size == forwardable_count &&
               @send_node.arguments.size == forwardable_count
           end
+
+          def missing_rest_arg_or_kwrest_arg?
+            (@rest_arg_name && !forwarded_rest_arg) ||
+              (@kwrest_arg_name && !forwarded_kwrest_arg)
+          end
+        end
+
+        def explicit_block_name?
+          block_forwarding_config = config.for_cop('Naming/BlockForwarding')
+          return false unless block_forwarding_config['Enabled']
+
+          block_forwarding_config['EnforcedStyle'] == 'explicit'
         end
       end
     end

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

@@ -23,6 +23,8 @@ module RuboCop
       #   array.reject { |e| e.nil? }
       #   array.delete_if { |e| e.nil? }
       #   array.select { |e| !e.nil? }
+      #   array.grep_v(nil)
+      #   array.grep_v(NilClass)
       #
       #   # good
       #   array.compact
@@ -46,7 +48,7 @@ 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 delete_if reject! select select! grep_v].freeze
         TO_ENUM_METHODS = %i[to_enum lazy].freeze
 
         minimum_target_ruby_version 2.4
@@ -79,6 +81,11 @@ module RuboCop
                 $(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 unless (range = offense_range(node))
           return if allowed_receiver?(node.receiver)
@@ -95,8 +102,9 @@ module RuboCop
 
         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
@@ -110,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/conditional_assignment.rb

@@ -233,7 +233,7 @@ module RuboCop
         PATTERN
 
         ASSIGNMENT_TYPES.each do |type|
-          define_method "on_#{type}" do |node|
+          define_method :"on_#{type}" do |node|
             return if part_of_ignored_node?(node)
             return if node.parent&.shorthand_asgn?
 

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

@@ -32,27 +32,27 @@ module RuboCop
 
           send_node = node.send_node
 
-          range = send_node.receiver.source_range.join(send_node.loc.selector)
-
-          add_offense(range) do |corrector|
+          add_offense(send_node) do |corrector|
             range_type, min, max = each_range(node)
 
             max += 1 if range_type == :irange
 
-            corrector.replace(node.send_node, "#{max - min}.times")
+            corrector.replace(send_node, "#{max - min}.times")
           end
         end
 
         private
 
         def offending?(node)
+          return false unless node.arguments.empty?
+
           each_range_with_zero_origin?(node) || each_range_without_block_argument?(node)
         end
 
         # @!method each_range(node)
         def_node_matcher :each_range, <<~PATTERN
           (block
-            (send
+            (call
               (begin
                 (${irange erange}
                   (int $_) (int $_)))
@@ -64,7 +64,7 @@ module RuboCop
         # @!method each_range_with_zero_origin?(node)
         def_node_matcher :each_range_with_zero_origin?, <<~PATTERN
           (block
-            (send
+            (call
               (begin
                 ({irange erange}
                   (int 0) (int _)))
@@ -76,7 +76,7 @@ module RuboCop
         # @!method each_range_without_block_argument?(node)
         def_node_matcher :each_range_without_block_argument?, <<~PATTERN
           (block
-            (send
+            (call
               (begin
                 ({irange erange}
                   (int _) (int _)))

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

@@ -128,17 +128,6 @@ module RuboCop
           node.method?(:eval) ? node.arguments.size >= 2 : true
         end
 
-        # FIXME: It's a Style/ConditionalAssignment's false positive.
-        # rubocop:disable Style/ConditionalAssignment
-        def with_lineno?(node)
-          if node.method?(:eval)
-            node.arguments.size == 4
-          else
-            node.arguments.size == 3
-          end
-        end
-        # rubocop:enable Style/ConditionalAssignment
-
         def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff)
           expected = expected_line(sign, line_diff)
           message = format(MSG_INCORRECT_LINE,