rubocop 1.73.2 → 1.75.0

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

@@ -77,6 +77,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -103,6 +103,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -73,7 +73,7 @@ module RuboCop
       #   require 'my_debugger/start'
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
-        BLOCK_TYPES = %i[block numblock kwbegin].freeze
+        BLOCK_TYPES = %i[block numblock itblock kwbegin].freeze
 
         def on_send(node)
           return if assumed_usage_context?(node)
@@ -120,7 +120,7 @@ module RuboCop
           return true if assumed_argument?(node)
 
           node.each_ancestor.none? do |ancestor|
-            BLOCK_TYPES.include?(ancestor.type) || ancestor.lambda_or_proc?
+            ancestor.type?(:any_block, :kwbegin) || ancestor.lambda_or_proc?
           end
         end
 

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

@@ -46,6 +46,10 @@ module RuboCop
           return unless node.lhs.truthy_literal?
 
           add_offense(node.lhs) do |corrector|
+            # Don't autocorrect `'foo' && return` because having `return` as
+            # the leftmost node can lead to a void value expression syntax error.
+            next if node.rhs.type?(:return, :break, :next)
+
             corrector.replace(node, node.rhs.source)
           end
         end

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

@@ -46,7 +46,7 @@ module RuboCop
         def on_return(return_node)
           return if return_value?(return_node)
 
-          return_node.each_ancestor(:block, :def, :defs) do |node|
+          return_node.each_ancestor(:any_block, :def, :defs) do |node|
             break if scoped_node?(node)
 
             # if a proc is passed to `Module#define_method` or
@@ -54,7 +54,7 @@ module RuboCop
             # non-local exit error
             break if define_method?(node.send_node)
 
-            next unless node.arguments?
+            next if node.argument_list.empty?
 
             if chained_send?(node.send_node)
               add_offense(return_node.loc.keyword)

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

@@ -3,15 +3,18 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for `raise` or `fail` statements which are
-      # raising `Exception` class.
+      # Checks for `raise` or `fail` statements which raise `Exception` or
+      # `Exception.new`. Use `StandardError` or a specific exception class instead.
       #
-      # You can specify a module name that will be an implicit namespace
-      # using `AllowedImplicitNamespaces` option. The cop cause a false positive
-      # for namespaced `Exception` when a namespace is omitted. This option can
-      # prevent the false positive by specifying a namespace to be omitted for
-      # `Exception`. Alternatively, make `Exception` a fully qualified class
-      # name with an explicit namespace.
+      # If you have defined your own namespaced `Exception` class, it is possible
+      # to configure the cop to allow it by setting `AllowedImplicitNamespaces` to
+      # an array with the names of the namespaces to allow. By default, this is set to
+      # `['Gem']`, which allows `Gem::Exception` to be raised without an explicit namespace.
+      # If not allowed, a false positive may be registered if `raise Exception` is called
+      # within the namespace.
+      #
+      # Alternatively, use a fully qualified name with `raise`/`fail`
+      # (eg. `raise Namespace::Exception`).
       #
       # @safety
       #   This cop is unsafe because it will change the exception class being
@@ -20,15 +23,31 @@ module RuboCop
       # @example
       #   # bad
       #   raise Exception, 'Error message here'
+      #   raise Exception.new('Error message here')
       #
       #   # good
       #   raise StandardError, 'Error message here'
+      #   raise MyError.new, 'Error message here'
+      #
+      # @example AllowedImplicitNamespaces: ['Gem'] (default)
+      #   # bad - `Foo` is not an allowed implicit namespace
+      #   module Foo
+      #     def self.foo
+      #       raise Exception # This is qualified to `Foo::Exception`.
+      #     end
+      #   end
       #
-      # @example AllowedImplicitNamespaces: ['Gem']
       #   # good
       #   module Gem
       #     def self.foo
-      #       raise Exception # This exception means `Gem::Exception`.
+      #       raise Exception # This is qualified to `Gem::Exception`.
+      #     end
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     def self.foo
+      #       raise Foo::Exception
       #     end
       #   end
       class RaiseException < Base

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

@@ -3,13 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for redundant uses of `to_s`, `to_sym`, `to_i`, `to_f`, `to_r`, `to_c`,
+      # Checks for redundant uses of `to_s`, `to_sym`, `to_i`, `to_f`, `to_d`, `to_r`, `to_c`,
       # `to_a`, `to_h`, and `to_set`.
       #
       # When one of these methods is called on an object of the same type, that object
       # is returned, making the call unnecessary. The cop detects conversion methods called
       # on object literals, class constructors, class `[]` methods, and the `Kernel` methods
-      # `String()`, `Integer()`, `Float()`, `Rational()`, `Complex()` and `Array()`.
+      # `String()`, `Integer()`, `Float()`, BigDecimal(), `Rational()`, `Complex()`, and `Array()`.
       #
       # Specifically, these cases are detected for each conversion method:
       #
@@ -98,6 +98,7 @@ module RuboCop
           to_s: 'string_constructor?',
           to_i: 'integer_constructor?',
           to_f: 'float_constructor?',
+          to_d: 'bigdecimal_constructor?',
           to_r: 'rational_constructor?',
           to_c: 'complex_constructor?',
           to_a: 'array_constructor?',
@@ -110,7 +111,7 @@ module RuboCop
         TYPED_METHODS = { to_s: %i[inspect] }.freeze
 
         CONVERSION_METHODS = Set[*LITERAL_NODE_TYPES.keys].freeze
-        RESTRICT_ON_SEND = CONVERSION_METHODS
+        RESTRICT_ON_SEND = CONVERSION_METHODS + [:to_d]
 
         private_constant :LITERAL_NODE_TYPES, :CONSTRUCTOR_MAPPING
 
@@ -137,6 +138,11 @@ module RuboCop
           #type_constructor?(:Float)
         PATTERN
 
+        # @!method bigdecimal_constructor?(node)
+        def_node_matcher :bigdecimal_constructor?, <<~PATTERN
+          #type_constructor?(:BigDecimal)
+        PATTERN
+
         # @!method rational_constructor?(node)
         def_node_matcher :rational_constructor?, <<~PATTERN
           #type_constructor?(:Rational)

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

@@ -53,6 +53,7 @@ module RuboCop
         # rubocop:enable Metrics/AbcSize
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -64,6 +65,8 @@ module RuboCop
               (args (arg _)) ...)
             (numblock
               $(call _ {:each_with_index :with_index} ...) 1 ...)
+            (itblock
+              $(call _ {:each_with_index :with_index} ...) _ ...)
           }
         PATTERN
 

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

@@ -49,6 +49,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -59,6 +60,8 @@ module RuboCop
               $(call _ {:each_with_object :with_object} _) (args (arg _)) ...)
             (numblock
               $(call _ {:each_with_object :with_object} _) 1 ...)
+            (itblock
+              $(call _ {:each_with_object :with_object} _) _ ...)
           }
         PATTERN
 

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

@@ -35,22 +35,15 @@ module RuboCop
         def on_return(return_node)
           return unless return_node.descendants.any?
 
-          context_node = non_void_context(return_node)
-
-          return unless context_node&.def_type?
-          return unless context_node&.void_context?
+          def_node = return_node.each_ancestor(:def).first
+          return unless def_node&.void_context?
+          return if return_node.each_ancestor(:any_block).any?(&:lambda?)
 
           add_offense(
             return_node.loc.keyword,
-            message: format(message, method: context_node.method_name)
+            message: format(message, method: def_node.method_name)
           )
         end
-
-        private
-
-        def non_void_context(return_node)
-          return_node.each_ancestor(:block, :def, :defs).first
-        end
       end
     end
   end

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

@@ -56,19 +56,26 @@ module RuboCop
 
           outer_local_variable = variable_table.find_variable(variable.name)
           return unless outer_local_variable
+          return if variable_used_in_declaration_of_outer?(variable, outer_local_variable)
           return if same_conditions_node_different_branch?(variable, outer_local_variable)
 
           message = format(MSG, variable: variable.name)
           add_offense(variable.declaration_node, message: message)
         end
 
+        private
+
+        def variable_used_in_declaration_of_outer?(variable, outer_local_variable)
+          variable.scope.node.each_ancestor.any?(outer_local_variable.declaration_node)
+        end
+
         def same_conditions_node_different_branch?(variable, outer_local_variable)
           variable_node = variable_node(variable)
           return false unless node_or_its_ascendant_conditional?(variable_node)
 
           outer_local_variable_node =
             find_conditional_node_from_ascendant(outer_local_variable.declaration_node)
-          return true unless outer_local_variable_node
+          return false unless outer_local_variable_node
           return false unless outer_local_variable_node.conditional?
           return true if variable_node == outer_local_variable_node
 

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

@@ -51,7 +51,18 @@ module RuboCop
 
         # @!method hash_initialized_with_mutable_shared_object?(node)
         def_node_matcher :hash_initialized_with_mutable_shared_object?, <<~PATTERN
-          (send (const {nil? cbase} :Hash) :new {array hash (send (const {nil? cbase} {:Array :Hash}) :new)})
+          {
+            (send (const {nil? cbase} :Hash) :new [
+              {array hash (send (const {nil? cbase} {:Array :Hash}) :new)}
+              !#capacity_keyword_argument?
+            ])
+            (send (const {nil? cbase} :Hash) :new hash #capacity_keyword_argument?)
+          }
+        PATTERN
+
+        # @!method capacity_keyword_argument?(node)
+        def_node_matcher :capacity_keyword_argument?, <<~PATTERN
+          (hash (pair (sym :capacity) _))
         PATTERN
 
         def on_send(node)

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

@@ -53,6 +53,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -74,6 +75,7 @@ module RuboCop
 
         def arg_count(node)
           return node.children[1] if node.numblock_type? # the maximum numbered param for the block
+          return 1 if node.itblock_type? # `it` block parameter is always one
 
           # Only `arg`, `optarg` and `mlhs` (destructuring) count as arguments that
           # can be used. Keyword arguments are not used for these methods so are

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

@@ -43,6 +43,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def after_block(node)
           @instance_eval_count -= 1 if instance_eval_block?(node)

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

@@ -101,9 +101,8 @@ module RuboCop
           check(node) if loop_method?(node)
         end
 
-        def on_numblock(node)
-          check(node) if loop_method?(node)
-        end
+        alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -189,8 +188,9 @@ module RuboCop
 
         def preceded_by_continue_statement?(break_statement)
           break_statement.left_siblings.any? do |sibling|
-            # Numblocks have the arguments count as a number in the AST.
-            next if sibling.is_a?(Integer)
+            # Numblocks have the arguments count as a number or,
+            # itblocks have `:it` symbol in the AST.
+            next if sibling.is_a?(Integer) || sibling.is_a?(Symbol)
             next if sibling.loop_keyword? || loop_method?(sibling)
 
             sibling.each_descendant(*CONTINUE_KEYWORDS).any?

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

@@ -143,6 +143,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # Checks for useless constant scoping. Private constants must be defined using
-      # `private_constant` or `class << self`. Even if `private` access modifier is used,
-      # it is public scope despite its appearance.
+      # `private_constant`. Even if `private` access modifier is used, it is public scope despite
+      # its appearance.
       #
       # It does not support autocorrection due to behavior change and multiple ways to fix it.
       # Or a public constant may be intended.
@@ -26,14 +26,6 @@ module RuboCop
       #
       #   # good
       #   class Foo
-      #     class << self
-      #       private
-      #       PRIVATE_CONST = 42
-      #     end
-      #   end
-      #
-      #   # good
-      #   class Foo
       #     PUBLIC_CONST = 42 # If private scope is not intended.
       #   end
       #
@@ -46,7 +38,6 @@ module RuboCop
         PATTERN
 
         def on_casgn(node)
-          return if node.each_ancestor(:sclass).any?
           return unless after_private_modifier?(node.left_siblings)
           return if private_constantize?(node.right_siblings, node.name)
 

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

@@ -86,6 +86,7 @@ module RuboCop
           check_expression(node.body)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_begin(node)
           check_begin(node)

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

@@ -57,6 +57,7 @@ module RuboCop
           check_code_length(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -63,6 +63,7 @@ module RuboCop
           check_code_length(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -145,7 +145,7 @@ module RuboCop
 
           def extract_body(node)
             case node.type
-            when :class, :module, :sclass, :block, :numblock, :def, :defs
+            when :class, :module, :sclass, :block, :numblock, :itblock, :def, :defs
               node.body
             when :casgn
               extract_body(node.expression)

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

@@ -48,7 +48,7 @@ module RuboCop
 
           args = process_args(node.arguments)
           return extract_breakable_node_from_elements(node, args, max)
-        elsif node.def_type?
+        elsif node.type?(:def, :defs)
           return extract_breakable_node_from_elements(node, node.arguments, max)
         elsif node.type?(:array, :hash)
           return extract_breakable_node_from_elements(node, node.children, max)
@@ -220,7 +220,7 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
-        return node.first_line != node.last_argument.last_line if node.def_type?
+        return node.first_line != node.last_argument.last_line if node.type?(:def, :defs)
 
         !node.single_line?
       end

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

@@ -35,7 +35,7 @@ module RuboCop
         comment_line_numbers = processed_source.comments.map { |comment| comment.loc.line }
 
         comment_line_numbers.any? do |comment_line_number|
-          comment_line_number >= node.first_line && comment_line_number <= node.last_line
+          comment_line_number.between?(node.first_line, node.last_line)
         end
       end
 

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain identifiers in a cop.
+    module ForbiddenIdentifiers
+      SIGILS = '@$' # if a variable starts with a sigil it will be removed
+
+      def forbidden_identifier?(name)
+        name = name.to_s.delete(SIGILS)
+
+        forbidden_identifiers.any? && forbidden_identifiers.include?(name)
+      end
+
+      def forbidden_identifiers
+        cop_config.fetch('ForbiddenIdentifiers', [])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain patterns in a cop.
+    module ForbiddenPattern
+      def forbidden_pattern?(name)
+        forbidden_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
+      end
+
+      def forbidden_patterns
+        cop_config.fetch('ForbiddenPatterns', [])
+      end
+    end
+  end
+end

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

@@ -30,6 +30,7 @@ module RuboCop
       end
 
       alias on_numblock on_block
+      alias on_itblock on_block
 
       private
 

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

@@ -29,7 +29,7 @@ module RuboCop
         min = required_minimum_ruby_version || 0
         max = required_maximum_ruby_version || Float::INFINITY
 
-        min <= version && max >= version
+        version.between?(min, max)
       end
     end
   end

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

@@ -6,14 +6,31 @@ module RuboCop
       # Makes sure that all methods use the configured style,
       # snake_case or camelCase, for their names.
       #
-      # This cop has `AllowedPatterns` configuration option.
+      # Method names matching patterns are always allowed.
       #
-      #   Naming/MethodName:
-      #     AllowedPatterns:
-      #       - '\AonSelectionBulkChange\z'
-      #       - '\AonSelectionCleared\z'
+      # The cop can be configured with `AllowedPatterns` to allow certain regexp patterns:
       #
-      # Method names matching patterns are always allowed.
+      # [source,yaml]
+      # ----
+      # Naming/MethodName:
+      #   AllowedPatterns:
+      #     - '\AonSelectionBulkChange\z'
+      #     - '\AonSelectionCleared\z'
+      # ----
+      #
+      # As well, you can also forbid specific method names or regexp patterns
+      # using `ForbiddenIdentifiers` or `ForbiddenPatterns`:
+      #
+      # [source,yaml]
+      # ----
+      # Naming/MethodName:
+      #   ForbiddenIdentifiers:
+      #     - 'def'
+      #     - 'super'
+      #   ForbiddenPatterns:
+      #     - '_v1\z'
+      #     - '_gen1\z'
+      # ----
       #
       # @example EnforcedStyle: snake_case (default)
       #   # bad
@@ -28,12 +45,26 @@ module RuboCop
       #
       #   # good
       #   def fooBar; end
+      #
+      # @example ForbiddenIdentifiers: ['def', 'super']
+      #   # bad
+      #   def def; end
+      #   def super; end
+      #
+      # @example ForbiddenPatterns: ['_v1\z', '_gen1\z']
+      #   # bad
+      #   def release_v1; end
+      #   def api_gen1; end
+      #
       class MethodName < Base
         include ConfigurableNaming
         include AllowedPattern
         include RangeHelp
+        include ForbiddenIdentifiers
+        include ForbiddenPattern
 
         MSG = 'Use %<style>s for method names.'
+        MSG_FORBIDDEN = '`%<identifier>s` is forbidden, use another method name instead.'
 
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
@@ -48,19 +79,44 @@ module RuboCop
             name = attr_name(name_item)
             next if !name || matches_allowed_pattern?(name)
 
-            check_name(node, name, range_position(node))
+            if forbidden_name?(name.to_s)
+              register_forbidden_name(node)
+            else
+              check_name(node, name, range_position(node))
+            end
           end
         end
 
         def on_def(node)
           return if node.operator_method? || matches_allowed_pattern?(node.method_name)
 
-          check_name(node, node.method_name, node.loc.name)
+          if forbidden_name?(node.method_name.to_s)
+            register_forbidden_name(node)
+          else
+            check_name(node, node.method_name, node.loc.name)
+          end
         end
         alias on_defs on_def
 
         private
 
+        def forbidden_name?(name)
+          forbidden_identifier?(name) || forbidden_pattern?(name)
+        end
+
+        def register_forbidden_name(node)
+          if node.type?(:def, :defs)
+            name_node = node.loc.name
+            method_name = node.method_name
+          else
+            attrs = node.attribute_accessor?
+            name_node = attrs.last.last
+            method_name = attr_name(name_node)
+          end
+          message = format(MSG_FORBIDDEN, identifier: method_name)
+          add_offense(name_node, message: message)
+        end
+
         def attr_name(name_item)
           sym_name(name_item) || str_name(name_item)
         end

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

@@ -53,6 +53,8 @@ module RuboCop
         include AllowedIdentifiers
         include ConfigurableNaming
         include AllowedPattern
+        include ForbiddenIdentifiers
+        include ForbiddenPattern
 
         MSG = 'Use %<style>s for variable names.'
         MSG_FORBIDDEN = '`%<identifier>s` is forbidden, use another name instead.'
@@ -92,27 +94,12 @@ module RuboCop
 
         private
 
-        def message(style)
-          format(MSG, style: style)
-        end
-
-        def forbidden_identifiers
-          cop_config.fetch('ForbiddenIdentifiers', [])
-        end
-
-        def forbidden_patterns
-          cop_config.fetch('ForbiddenPatterns', [])
-        end
-
-        def matches_forbidden_pattern?(name)
-          forbidden_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
-        end
-
         def forbidden_name?(name)
-          name = name.to_s.delete(SIGILS)
+          forbidden_identifier?(name) || forbidden_pattern?(name)
+        end
 
-          (forbidden_identifiers.any? && forbidden_identifiers.include?(name)) ||
-            (forbidden_patterns.any? && matches_forbidden_pattern?(name))
+        def message(style)
+          format(MSG, style: style)
         end
 
         def register_forbidden_name(node)