rubocop 1.64.0 → 1.65.0

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

@@ -3,12 +3,12 @@
 module RuboCop
   module Cop
     module Metrics
-      # Checks for excessive nesting of conditional and looping
-      # constructs.
+      # Checks for excessive nesting of conditional and looping constructs.
       #
-      # You can configure if blocks are considered using the `CountBlocks`
-      # option. When set to `false` (the default) blocks are not counted
-      # towards the nesting level. Set to `true` to count blocks as well.
+      # You can configure if blocks are considered using the `CountBlocks` and `CountModifierForms`
+      # options. When both are set to `false` (the default) blocks and modifier forms are not
+      # counted towards the nesting level. Set them to `true` to include these in the nesting level
+      # calculation as well.
       #
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Base
@@ -27,7 +27,7 @@ module RuboCop
 
         def check_nesting_level(node, max, current_level)
           if consider_node?(node)
-            current_level += 1 unless node.if_type? && node.elsif?
+            current_level += 1 if count_if_block?(node)
             if current_level > max
               self.max = current_level
               unless part_of_ignored_node?(node)
@@ -41,6 +41,14 @@ module RuboCop
           end
         end
 
+        def count_if_block?(node)
+          return true unless node.if_type?
+          return false if node.elsif?
+          return count_modifier_forms? if node.modifier_form?
+
+          true
+        end
+
         def consider_node?(node)
           return true if NESTING_BLOCKS.include?(node.type)
 
@@ -52,7 +60,11 @@ module RuboCop
         end
 
         def count_blocks?
-          cop_config['CountBlocks']
+          cop_config.fetch('CountBlocks', false)
+        end
+
+        def count_modifier_forms?
+          cop_config.fetch('CountModifierForms', false)
         end
       end
     end

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

@@ -65,8 +65,12 @@ module RuboCop
         inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
       end
 
-      # @deprecated Use processed_source.comment_at_line(line)
+      # @deprecated Use processed_source.line_with_comment?(line)
       def end_of_line_comment(line)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `end_of_line_comment` is deprecated. Use `processed_source.line_with_comment?` instead.
+        WARNING
+
         processed_source.line_with_comment?(line)
       end
 

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

@@ -15,7 +15,13 @@ module RuboCop
       end
 
       # @deprecated Use allowed_method? instead
-      alias ignored_method? allowed_method?
+      def ignored_method?
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `ignored_method?` is deprecated. Use `allowed_method?` instead.
+        WARNING
+
+        allowed_method?
+      end
 
       # @api public
       def allowed_methods

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

@@ -18,14 +18,26 @@ module RuboCop
       end
 
       # @deprecated Use allowed_line? instead
-      alias ignored_line? allowed_line?
+      def ignored_line?
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `ignored_line?` is deprecated. Use `allowed_line?` instead.
+        WARNING
+
+        allowed_line?
+      end
 
       def matches_allowed_pattern?(line)
         allowed_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
       end
 
-      # @deprecated Use matches_allowed_pattern?? instead
-      alias matches_ignored_pattern? matches_allowed_pattern?
+      # @deprecated Use matches_allowed_pattern? instead
+      def matches_ignored_pattern?
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `matches_ignored_pattern?` is deprecated. Use `matches_allowed_pattern?` instead.
+        WARNING
+
+        matches_allowed_pattern?
+      end
 
       def allowed_patterns
         # Since there could be a pattern specified in the default config, merge the two

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

@@ -4,11 +4,15 @@ module RuboCop
   module Cop
     # Handles `Max` configuration parameters, especially setting them to an
     # appropriate value with --auto-gen-config.
-    # @deprecated Use `exclude_limit ParameterName` instead.
+    # @deprecated Use `exclude_limit <ParameterName>` instead.
     module ConfigurableMax
       private
 
       def max=(value)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `max=` is deprecated. Use `exclude_limit <ParameterName>` instead.
+        WARNING
+
         cfg = config_to_allow_offenses
         cfg[:exclude_limit] ||= {}
         current_max = cfg[:exclude_limit][max_parameter_name]

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

@@ -18,6 +18,10 @@ module RuboCop
 
       # @deprecated Use ResbodyNode#exceptions instead
       def rescued_exceptions(resbody)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `rescued_exceptions` is deprecated. Use `ResbodyNode#exceptions` instead.
+        WARNING
+
         rescue_group, = *resbody
         if rescue_group
           rescue_group.values

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

@@ -148,7 +148,7 @@ module RuboCop
 
           restarg, kwrestarg, blockarg = extract_forwardable_args(node.arguments)
           forwardable_args = redundant_forwardable_named_args(restarg, kwrestarg, blockarg)
-          send_nodes = node.each_descendant(:send, :csend, :super).to_a
+          send_nodes = node.each_descendant(:send, :csend, :super, :yield).to_a
 
           send_classifications = classify_send_nodes(
             node, send_nodes, non_splat_or_block_pass_lvar_references(node.body), forwardable_args

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

@@ -58,12 +58,15 @@ module RuboCop
         end
 
         def verify_autocorrect_notice!
-          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+          if autocorrect_notice.nil? || autocorrect_notice.empty?
+            raise Warning, "#{cop_name}: #{AUTOCORRECT_EMPTY_WARNING}"
+          end
 
           regex = Regexp.new(notice)
           return if autocorrect_notice.gsub(/^# */, '').match?(regex)
 
-          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
+          message = "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
+          raise Warning, "#{cop_name}: #{message}"
         end
 
         def insert_notice_before(processed_source)

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

@@ -29,36 +29,36 @@ module RuboCop
       #   end
       #
       #   # allowed
-      #     # Class without body
+      #   # Class without body
+      #   class Person
+      #   end
+      #
+      #   # Namespace - A namespace can be a class or a module
+      #   # Containing a class
+      #   module Namespace
+      #     # Description/Explanation of Person class
       #     class Person
+      #       # ...
       #     end
+      #   end
       #
-      #     # Namespace - A namespace can be a class or a module
-      #     # Containing a class
-      #     module Namespace
-      #       # Description/Explanation of Person class
-      #       class Person
-      #         # ...
-      #       end
+      #   # Containing constant visibility declaration
+      #   module Namespace
+      #     class Private
       #     end
       #
-      #     # Containing constant visibility declaration
-      #     module Namespace
-      #       class Private
-      #       end
-      #
-      #       private_constant :Private
-      #     end
+      #     private_constant :Private
+      #   end
       #
-      #     # Containing constant definition
-      #     module Namespace
-      #       Public = Class.new
-      #     end
+      #   # Containing constant definition
+      #   module Namespace
+      #     Public = Class.new
+      #   end
       #
-      #     # Macro calls
-      #     module Namespace
-      #       extend Foo
-      #     end
+      #   # Macro calls
+      #   module Namespace
+      #     extend Foo
+      #   end
       #
       # @example AllowedConstants: ['ClassMethods']
       #
@@ -67,7 +67,7 @@ module RuboCop
       #      module ClassMethods
       #        # ...
       #      end
-      #     end
+      #    end
       #
       class Documentation < Base
         include DocumentationComment

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

@@ -23,9 +23,9 @@ module RuboCop
       #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar }
       #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar }
       #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar }
-      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[foo bar].include?(k) }
-      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[foo bar].include?(k) }
-      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[foo bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[bar].include?(k) }
       #
       #   # good
       #   {foo: 1, bar: 2, baz: 3}.except(:bar)
@@ -73,8 +73,9 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          method_name = node.method_name
           block = node.parent
-          return unless bad_method?(block) && semantically_except_method?(node, block)
+          return unless bad_method?(method_name, block) && semantically_except_method?(node, block)
 
           except_key = except_key(block)
           return if except_key.nil? || !safe_to_register_offense?(block, except_key)
@@ -91,7 +92,7 @@ module RuboCop
         private
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def bad_method?(block)
+        def bad_method?(method_name, block)
           if active_support_extensions_enabled?
             bad_method_with_active_support?(block) do |key_arg, send_node|
               if send_node.method?(:in?) && send_node.receiver&.source != key_arg.source
@@ -103,6 +104,8 @@ module RuboCop
             end
           else
             bad_method_with_poro?(block) do |key_arg, send_node|
+              return false if method_name == :reject && block.body.method?(:!)
+
               !send_node.method?(:include?) || send_node.first_argument&.source == key_arg.source
             end
           end

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Prefer `select` or `reject` over `map { ... }.compact`.
+      # This cop also handles `filter_map { ... }`, similar to `map { ... }.compact`.
       #
       # @example
       #
@@ -11,6 +12,9 @@ module RuboCop
       #   array.map { |e| some_condition? ? e : next }.compact
       #
       #   # bad
+      #   array.filter_map { |e| some_condition? ? e : next }
+      #
+      #   # bad
       #   array.map do |e|
       #     if some_condition?
       #       e
@@ -40,55 +44,73 @@ module RuboCop
       class MapCompactWithConditionalBlock < Base
         extend AutoCorrector
 
-        MSG = 'Replace `map { ... }.compact` with `%<method>s`.'
-
-        # @!method map_and_compact?(node)
-        def_node_matcher :map_and_compact?, <<~RUBY
-          (call
-            (block
-              (call _ :map)
-              (args
-                $(arg _))
-              {
-                (if $_ $(lvar _) {next nil?})
-                (if $_ {next nil?} $(lvar _))
-                (if $_ (next $(lvar _)) {next nil nil?})
-                (if $_ {next nil nil?} (next $(lvar _)))
-                (begin
-                  {
-                    (if $_ next nil?)
-                    (if $_ nil? next)
-                  }
-                  $(lvar _))
-                (begin
-                  {
-                    (if $_ (next $(lvar _)) nil?)
-                    (if $_ nil? (next $(lvar _)))
-                  }
-                  (nil))
-              }) :compact)
+        MSG = 'Replace `%<current>s` with `%<method>s`.'
+        RESTRICT_ON_SEND = %i[compact filter_map].freeze
+
+        # @!method conditional_block(node)
+        def_node_matcher :conditional_block, <<~RUBY
+          (block
+            (call _ {:map :filter_map})
+            (args
+              $(arg _))
+            {
+              (if $_ $(lvar _) {next nil?})
+              (if $_ {next nil?} $(lvar _))
+              (if $_ (next $(lvar _)) {next nil nil?})
+              (if $_ {next nil nil?} (next $(lvar _)))
+              (begin
+                {
+                  (if $_ next nil?)
+                  (if $_ nil? next)
+                }
+                $(lvar _))
+              (begin
+                {
+                  (if $_ (next $(lvar _)) nil?)
+                  (if $_ nil? (next $(lvar _)))
+                }
+                (nil))
+            })
         RUBY
 
         def on_send(node)
-          map_and_compact?(node) do |block_argument_node, condition_node, return_value_node|
-            return unless returns_block_argument?(block_argument_node, return_value_node)
-            return if condition_node.parent.elsif?
-
-            method = truthy_branch?(return_value_node) ? 'select' : 'reject'
-            range = range(node)
-
-            add_offense(range, message: format(MSG, method: method)) do |corrector|
-              corrector.replace(
-                range,
-                "#{method} { |#{block_argument_node.source}| #{condition_node.source} }"
-              )
-            end
+          map_candidate = node.children.first
+          if (block_argument, condition, return_value = conditional_block(map_candidate))
+            return unless node.method?(:compact) && node.arguments.empty?
+
+            range = map_with_compact_range(node)
+          elsif (block_argument, condition, return_value = conditional_block(node.parent))
+            return unless node.method?(:filter_map)
+
+            range = filter_map_range(node)
+          else
+            return
           end
+
+          inspect(node, block_argument, condition, return_value, range)
         end
         alias on_csend on_send
 
         private
 
+        def inspect(node, block_argument_node, condition_node, return_value_node, range)
+          return unless returns_block_argument?(block_argument_node, return_value_node)
+          return if condition_node.parent.elsif?
+
+          method = truthy_branch?(return_value_node) ? 'select' : 'reject'
+          current = current(node)
+
+          add_offense(range, message: format(MSG, current: current, method: method)) do |corrector|
+            return if part_of_ignored_node?(node) || ignored_node?(node)
+
+            corrector.replace(
+              range, "#{method} { |#{block_argument_node.source}| #{condition_node.source} }"
+            )
+
+            ignore_node(node)
+          end
+        end
+
         def returns_block_argument?(block_argument_node, return_value_node)
           block_argument_node.name == return_value_node.children.first
         end
@@ -123,10 +145,22 @@ module RuboCop
           end
         end
 
-        def range(node)
-          map_node = node.receiver.send_node
+        def current(node)
+          if node.method?(:compact)
+            map_or_filter_map_method = node.children.first
+
+            "#{map_or_filter_map_method.method_name} { ... }.compact"
+          else
+            'filter_map { ... }'
+          end
+        end
+
+        def map_with_compact_range(node)
+          node.receiver.send_node.loc.selector.begin.join(node.source_range.end)
+        end
 
-          map_node.loc.selector.join(node.source_range.end)
+        def filter_map_range(node)
+          node.loc.selector.join(node.parent.source_range.end)
         end
       end
     end

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

@@ -18,6 +18,7 @@ module RuboCop
             return if inside_endless_method_def?(node)
             return if require_parentheses_for_hash_value_omission?(node)
             return if syntax_like_method_call?(node)
+            return if method_call_before_constant_resolution?(node)
             return if super_call_without_arguments?(node)
             return if legitimate_call_with_parentheses?(node)
             return if allowed_camel_case_method_call?(node)
@@ -63,6 +64,10 @@ module RuboCop
             node.implicit_call? || node.operator_method?
           end
 
+          def method_call_before_constant_resolution?(node)
+            node.parent&.const_type?
+          end
+
           def super_call_without_arguments?(node)
             node.super_type? && node.arguments.none?
           end

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

@@ -9,7 +9,7 @@ module RuboCop
       #
       # String interpolation is always kept in double quotes.
       #
-      # Note: `Lint/SymbolConversion` can be used in parallel to ensure that symbols
+      # NOTE: `Lint/SymbolConversion` can be used in parallel to ensure that symbols
       # are not quoted that don't need to be. This cop is for configuring the quoting
       # style to use for symbols that require quotes.
       #

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

@@ -75,7 +75,7 @@ module RuboCop
 
         def on_def(node)
           return unless node.body&.kwbegin_type?
-          return if node.endless? && !node.body.children.one?
+          return if node.endless?
 
           register_offense(node.body)
         end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks for the presence of superfluous `.rb` extension in
       # the filename provided to `require` and `require_relative`.
       #
-      # Note: If the extension is omitted, Ruby tries adding '.rb', '.so',
+      # NOTE: If the extension is omitted, Ruby tries adding '.rb', '.so',
       #       and so on to the name until found. If the file named cannot be found,
       #       a `LoadError` will be raised.
       #       There is an edge case where `foo.so` file is loaded instead of a `LoadError`

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

@@ -74,6 +74,7 @@ module RuboCop
           kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
           tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
         ].freeze
+        ARGUMENT_TAKING_FLOW_TOKEN_TYPES = %i[tIDENTIFIER kRETURN kBREAK kNEXT kYIELD].freeze
 
         def on_new_investigation
           return unless processed_source.ast
@@ -137,7 +138,7 @@ module RuboCop
         #   do_something \
         #     argument
         def method_with_argument?(current_token, next_token)
-          return false if current_token.type != :tIDENTIFIER && current_token.type != :kRETURN
+          return false unless ARGUMENT_TAKING_FLOW_TOKEN_TYPES.include?(current_token.type)
 
           ARGUMENT_TYPES.include?(next_token.type)
         end

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

@@ -7,6 +7,20 @@ module RuboCop
       # Since the `send` method can be used to call private methods, by default,
       # only the `public_send` method is detected.
       #
+      # NOTE: Writer methods with names ending in `=` are always permitted because their
+      # behavior differs as follows:
+      #
+      # [source,ruby]
+      # ----
+      # def foo=(foo)
+      #   @foo = foo
+      #   42
+      # end
+      #
+      # self.foo = 1   # => 1
+      # send(:foo=, 1) # => 42
+      # ----
+      #
       # @safety
       #   This cop is not safe because it can incorrectly detect based on the receiver.
       #   Additionally, when `AllowSend` is set to `true`, it cannot determine whether
@@ -43,8 +57,14 @@ module RuboCop
         MSG = 'Use `%<method_name>s` method call directly instead.'
         RESTRICT_ON_SEND = %i[public_send send __send__].freeze
         STATIC_METHOD_NAME_NODE_TYPES = %i[sym str].freeze
+        METHOD_NAME_PATTERN = /\A[a-zA-Z_][a-zA-Z0-9_]*[!?]?\z/.freeze
+        RESERVED_WORDS = %i[
+          BEGIN END alias and begin break case class def defined? do else elsif end ensure
+          false for if in module next nil not or redo rescue retry return self super then true
+          undef unless until when while yield
+        ].freeze
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return if allow_send? && !node.method?(:public_send)
           return unless (first_argument = node.first_argument)
@@ -52,6 +72,7 @@ module RuboCop
 
           offense_range = offense_range(node)
           method_name = first_argument.value
+          return if !METHOD_NAME_PATTERN.match?(method_name) || RESERVED_WORDS.include?(method_name)
 
           add_offense(offense_range, message: format(MSG, method_name: method_name)) do |corrector|
             if node.arguments.one?
@@ -62,7 +83,7 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private