rubocop 1.67.0 → 1.75.7

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

@@ -5,17 +5,16 @@ module RuboCop
     module Lint
       # Checks for places where binary operator has identical operands.
       #
-      # It covers arithmetic operators: `-`, `/`, `%`;
-      # comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, ``<=``;
+      # It covers comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, ``<=``;
       # bitwise operators: `|`, `^`, `&`;
       # boolean operators: `&&`, `||`
       # and "spaceship" operator - ``<=>``.
       #
       # Simple arithmetic operations are allowed by this cop: `+`, `*`, `**`, `<<` and `>>`.
       # Although these can be rewritten in a different way, it should not be necessary to
-      # do so. This does not include operations such as `-` or `/` where the result will
-      # always be the same (`x - x` will always be 0; `x / x` will always be 1), and
-      # thus are legitimate offenses.
+      # do so. Operations such as `-` or `/` where the result will always be the same
+      # (`x - x` will always be 0; `x / x` will always be 1) are offenses, but these
+      # are covered by `Lint/NumericOperationWithConstantResult` instead.
       #
       # @safety
       #   This cop is unsafe as it does not consider side effects when calling methods
@@ -30,7 +29,6 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   x / x
       #   x.top >= x.top
       #
       #   if a.x != 0 && a.x != 0
@@ -47,19 +45,19 @@ module RuboCop
       #
       class BinaryOperatorWithIdenticalOperands < Base
         MSG = 'Binary operator `%<op>s` has identical operands.'
-        ALLOWED_MATH_OPERATORS = %i[+ * ** << >>].to_set.freeze
+        RESTRICT_ON_SEND = %i[== != === <=> =~ && || > >= < <= | ^].freeze
 
         def on_send(node)
           return unless node.binary_operation?
+          return unless node.receiver == node.first_argument
 
-          lhs, operation, rhs = *node
-          return if ALLOWED_MATH_OPERATORS.include?(node.method_name)
-
-          add_offense(node, message: format(MSG, op: operation)) if lhs == rhs
+          add_offense(node, message: format(MSG, op: node.method_name))
         end
 
         def on_and(node)
-          add_offense(node, message: format(MSG, op: node.operator)) if node.lhs == node.rhs
+          return unless node.lhs == node.rhs
+
+          add_offense(node, message: format(MSG, op: node.operator))
         end
         alias on_or on_and
       end

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

@@ -48,7 +48,7 @@ module RuboCop
         def autocorrect(corrector, node)
           boolean_literal = node.source.delete(':')
           parent = node.parent
-          if parent&.pair_type? && node.equal?(parent.children[0])
+          if parent&.pair_type? && parent.colon? && node.equal?(parent.children[0])
             corrector.remove(parent.loc.operator)
             boolean_literal = "#{node.source} =>"
           end

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

@@ -6,7 +6,8 @@ module RuboCop
       # Checks for circular argument references in optional keyword
       # arguments and optional ordinal arguments.
       #
-      # This cop mirrors a warning produced by MRI since 2.2.
+      # NOTE: This syntax was made invalid on Ruby 2.7 - Ruby 3.3 but is allowed
+      # again since Ruby 3.4.
       #
       # @example
       #
@@ -35,6 +36,8 @@ module RuboCop
       #     dry_ingredients.combine
       #   end
       class CircularArgumentReference < Base
+        extend TargetRubyVersion
+
         MSG = 'Circular argument reference - `%<arg_name>s`.'
 
         def on_kwoptarg(node)

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

@@ -68,12 +68,12 @@ module RuboCop
 
         # @!method constant_assigned_in_block?(node)
         def_node_matcher :constant_assigned_in_block?, <<~PATTERN
-          ({^block_type? [^begin_type? ^^block_type?]} nil? ...)
+          ({^any_block [^begin ^^any_block]} nil? ...)
         PATTERN
 
         # @!method module_defined_in_block?(node)
         def_node_matcher :module_defined_in_block?, <<~PATTERN
-          ({^block_type? [^begin_type? ^^block_type?]} ...)
+          ({^any_block [^begin ^^any_block]} ...)
         PATTERN
 
         def on_casgn(node)
@@ -92,7 +92,7 @@ module RuboCop
         private
 
         def method_name(node)
-          node.ancestors.find(&:block_type?).method_name
+          node.ancestors.find(&:any_block_type?).method_name
         end
       end
     end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for constant reassignments.
+      #
+      # Emulates Ruby's runtime warning "already initialized constant X"
+      # when a constant is reassigned in the same file and namespace using the
+      # `NAME = value` syntax.
+      #
+      # The cop cannot catch all offenses, like, for example, when a constant
+      # is reassigned in another file, or when using metaprogramming (`Module#const_set`).
+      #
+      # The cop only takes into account constants assigned in a "simple" way: directly
+      # inside class/module definition, or within another constant. Other type of assignments
+      # (e.g., inside a conditional) are disregarded.
+      #
+      # The cop also tracks constant removal using `Module#remove_const` with symbol
+      # or string argument.
+      #
+      # @example
+      #   # bad
+      #   X = :foo
+      #   X = :bar
+      #
+      #   # bad
+      #   class A
+      #     X = :foo
+      #     X = :bar
+      #   end
+      #
+      #   # bad
+      #   module A
+      #     X = :foo
+      #     X = :bar
+      #   end
+      #
+      #   # good - keep only one assignment
+      #   X = :bar
+      #
+      #   class A
+      #     X = :bar
+      #   end
+      #
+      #   module A
+      #     X = :bar
+      #   end
+      #
+      #   # good - use OR assignment
+      #   X = :foo
+      #   X ||= :bar
+      #
+      #   # good - use conditional assignment
+      #   X = :foo
+      #   X = :bar unless defined?(X)
+      #
+      #   # good - remove the assigned constant first
+      #   class A
+      #     X = :foo
+      #     remove_const :X
+      #     X = :bar
+      #   end
+      #
+      class ConstantReassignment < Base
+        MSG = 'Constant `%<constant>s` is already assigned in this namespace.'
+
+        RESTRICT_ON_SEND = %i[remove_const].freeze
+
+        # @!method remove_constant(node)
+        def_node_matcher :remove_constant, <<~PATTERN
+          (send _ :remove_const
+            ({sym str} $_))
+        PATTERN
+
+        def on_casgn(node)
+          return unless fixed_constant_path?(node)
+          return unless simple_assignment?(node)
+          return if constant_names.add?(fully_qualified_constant_name(node))
+
+          add_offense(node, message: format(MSG, constant: node.name))
+        end
+
+        def on_send(node)
+          constant = remove_constant(node)
+
+          return unless constant
+
+          namespaces = ancestor_namespaces(node)
+
+          return if namespaces.none?
+
+          constant_names.delete(fully_qualified_name_for(namespaces, constant))
+        end
+
+        private
+
+        def fixed_constant_path?(node)
+          node.each_path.all? { |path| path.type?(:cbase, :const, :self) }
+        end
+
+        def simple_assignment?(node)
+          node.ancestors.all? do |ancestor|
+            return true if ancestor.type?(:module, :class)
+
+            ancestor.begin_type? || ancestor.literal? || ancestor.casgn_type? ||
+              freeze_method?(ancestor)
+          end
+        end
+
+        def freeze_method?(node)
+          node.send_type? && node.method?(:freeze)
+        end
+
+        def fully_qualified_constant_name(node)
+          if node.absolute?
+            namespace = node.namespace.const_type? ? node.namespace.source : nil
+
+            "#{namespace}::#{node.name}"
+          else
+            constant_namespaces = ancestor_namespaces(node) + constant_namespaces(node)
+
+            fully_qualified_name_for(constant_namespaces, node.name)
+          end
+        end
+
+        def fully_qualified_name_for(namespaces, constant)
+          ['', *namespaces, constant].join('::')
+        end
+
+        def constant_namespaces(node)
+          node.each_path.select(&:const_type?).map(&:short_name)
+        end
+
+        def ancestor_namespaces(node)
+          node
+            .each_ancestor(:class, :module)
+            .map { |ancestor| ancestor.identifier.short_name }
+            .reverse
+        end
+
+        def constant_names
+          @constant_names ||= Set.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable Style/DoubleCopDisableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that `# rubocop:enable ...` and `# rubocop:disable ...` statements
+      # are strictly formatted.
+      #
+      # A comment can be added to the directive by prefixing it with `--`.
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable Layout/LineLength Style/Encoding
+      #   #                                  ^ missing comma
+      #
+      #   # bad
+      #   # rubocop:disable
+      #
+      #   # bad
+      #   # rubocop:disable Layout/LineLength # rubocop:disable Style/Encoding
+      #
+      #   # bad
+      #   # rubocop:wrongmode Layout/LineLength
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength, Style/Encoding
+      #
+      #   # good
+      #   # rubocop:disable all
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength -- This is a good comment.
+      #
+      class CopDirectiveSyntax < Base
+        COMMON_MSG = 'Malformed directive comment detected.'
+
+        MISSING_MODE_NAME_MSG = 'The mode name is missing.'
+        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, or `todo`.'
+        MISSING_COP_NAME_MSG = 'The cop name is missing.'
+        MALFORMED_COP_NAMES_MSG = 'Cop names must be separated by commas. ' \
+                                  'Comment in the directive must start with `--`.'
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            directive_comment = DirectiveComment.new(comment)
+            next unless directive_comment.start_with_marker?
+            next unless directive_comment.malformed?
+
+            message = offense_message(directive_comment)
+            add_offense(comment, message: message)
+          end
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def offense_message(directive_comment)
+          comment = directive_comment.comment
+          after_marker = comment.text.sub(DirectiveComment::DIRECTIVE_MARKER_REGEXP, '')
+          mode = after_marker.split(' ', 2).first
+          additional_msg = if mode.nil?
+                             MISSING_MODE_NAME_MSG
+                           elsif !DirectiveComment::AVAILABLE_MODES.include?(mode)
+                             INVALID_MODE_NAME_MSG
+                           elsif directive_comment.missing_cop_name?
+                             MISSING_COP_NAME_MSG
+                           else
+                             MALFORMED_COP_NAMES_MSG
+                           end
+
+          "#{COMMON_MSG} #{additional_msg}"
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+    end
+  end
+end
+# rubocop:enable Lint/RedundantCopDisableDirective
+# rubocop:enable Style/DoubleCopDisableDirective

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)
@@ -116,11 +116,11 @@ module RuboCop
 
         def assumed_usage_context?(node)
           # Basically, debugger methods are not used as a method argument without arguments.
-          return false unless node.arguments.empty? && node.each_ancestor(:send, :csend).any?
+          return false unless node.arguments.empty? && node.each_ancestor(:call).any?
           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/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/deprecated_open_ssl_constant.rb

@@ -33,6 +33,7 @@ module RuboCop
 
         MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)` instead of `%<original>s`.'
 
+        RESTRICT_ON_SEND = %i[new digest].freeze
         NO_ARG_ALGORITHM = %w[BF DES IDEA RC4].freeze
 
         # @!method algorithm_const(node)
@@ -51,7 +52,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if node.arguments.any? { |arg| arg.variable? || arg.send_type? || arg.const_type? }
+          return if node.arguments.any? { |arg| arg.variable? || arg.call_type? || arg.const_type? }
           return if digest_const?(node.receiver)
           return unless algorithm_const(node)
 
@@ -133,7 +134,7 @@ module RuboCop
           if NO_ARG_ALGORITHM.include?(algorithm_parts.first.upcase) && no_arguments
             "'#{algorithm_parts.first}'"
           else
-            mode = 'cbc' unless size_and_mode == ['cbc']
+            mode = 'cbc' if size_and_mode.empty?
 
             "'#{(algorithm_parts + size_and_mode + [mode]).compact.take(3).join('-')}'"
           end

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

@@ -15,6 +15,9 @@ module RuboCop
       # With `IgnoreConstantBranches: true`, branches are not registered
       # as offenses if they return a constant value.
       #
+      # With `IgnoreDuplicateElseBranch: true`, in conditionals with multiple branches,
+      # duplicate 'else' branches are not registered as offenses.
+      #
       # @example
       #   # bad
       #   if foo
@@ -83,21 +86,37 @@ module RuboCop
       #   else MEDIUM_SIZE
       #   end
       #
+      # @example IgnoreDuplicateElseBranch: true
+      #   # good
+      #   if foo
+      #     do_foo
+      #   elsif bar
+      #     do_bar
+      #   else
+      #     do_foo
+      #   end
+      #
       class DuplicateBranch < Base
         MSG = 'Duplicate branch body detected.'
 
         def on_branching_statement(node)
-          branches(node).each_with_object(Set.new) do |branch, previous|
-            next unless consider_branch?(branch)
+          branches = branches(node)
+          branches.each_with_object(Set.new) do |branch, previous|
+            next unless consider_branch?(branches, branch)
 
             add_offense(offense_range(branch)) unless previous.add?(branch)
           end
         end
-        alias on_if on_branching_statement
         alias on_case on_branching_statement
         alias on_case_match on_branching_statement
         alias on_rescue on_branching_statement
 
+        def on_if(node)
+          # Ignore 'elsif' nodes, because we don't want to check them separately whether
+          # the 'else' branch is duplicated. We want to check only on the outermost conditional.
+          on_branching_statement(node) unless node.elsif?
+        end
+
         private
 
         def offense_range(duplicate_branch)
@@ -118,10 +137,14 @@ module RuboCop
           node.branches.compact
         end
 
-        def consider_branch?(branch)
+        def consider_branch?(branches, branch)
           return false if ignore_literal_branches? && literal_branch?(branch)
           return false if ignore_constant_branches? && const_branch?(branch)
 
+          if ignore_duplicate_else_branches? && duplicate_else_branch?(branches, branch)
+            return false
+          end
+
           true
         end
 
@@ -133,6 +156,10 @@ module RuboCop
           cop_config.fetch('IgnoreConstantBranches', false)
         end
 
+        def ignore_duplicate_else_branches?
+          cop_config.fetch('IgnoreDuplicateElseBranch', false)
+        end
+
         def literal_branch?(branch) # rubocop:disable Metrics/CyclomaticComplexity
           return false if !branch.literal? || branch.xstr_type?
           return true if branch.basic_literal?
@@ -147,6 +174,14 @@ module RuboCop
         def const_branch?(branch)
           branch.const_type?
         end
+
+        def duplicate_else_branch?(branches, branch)
+          return false unless (parent = branch.parent)
+
+          branches.size > 2 &&
+            branch.equal?(branches.last) &&
+            parent.respond_to?(:else?) && parent.else?
+        end
       end
     end
   end

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

@@ -106,7 +106,7 @@ module RuboCop
         private
 
         def pattern_identity(pattern)
-          pattern_source = if pattern.hash_pattern_type? || pattern.match_alt_type?
+          pattern_source = if pattern.type?(:hash_pattern, :match_alt)
                              pattern.children.map(&:source).sort.to_s
                            else
                              pattern.source

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

@@ -39,10 +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
-        DEF_TYPES = %i[def defs].freeze
+        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr
+                              delegate].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -54,14 +96,12 @@ module RuboCop
           # if a method definition is inside an if, it is very likely
           # that a different definition is used depending on platform, etc.
           return if node.each_ancestor.any?(&:if_type?)
-          return if possible_dsl?(node)
 
           found_instance_method(node, node.method_name)
         end
 
         def on_defs(node)
           return if node.each_ancestor.any?(&:if_type?)
-          return if possible_dsl?(node)
 
           if node.receiver.const_type?
             _, const_name = *node.receiver
@@ -79,7 +119,6 @@ module RuboCop
         def on_alias(node)
           return unless (name = method_alias?(node))
           return if node.ancestors.any?(&:if_type?)
-          return if possible_dsl?(node)
 
           found_instance_method(node, name)
         end
@@ -89,16 +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) _) ...>)
+          )
+        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?)
-            return if possible_dsl?(node)
 
             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
 
@@ -123,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)
 
@@ -166,7 +243,7 @@ module RuboCop
         end
 
         def method_key(node, method_name)
-          if (ancestor_def = node.each_ancestor(*DEF_TYPES).first)
+          if (ancestor_def = node.each_ancestor(:any_def).first)
             "#{ancestor_def.method_name}.#{method_name}"
           else
             method_name
@@ -174,7 +251,7 @@ module RuboCop
         end
 
         def location(node)
-          if DEF_TYPES.include?(node.type)
+          if node.any_def_type?
             node.loc.keyword.join(node.loc.name)
           else
             node.source_range
@@ -237,16 +314,6 @@ module RuboCop
           end
         end
 
-        def possible_dsl?(node)
-          # DSL methods may evaluate a block in the context of a newly created
-          # class or module
-          # Assume that if a method definition is inside any block call which
-          # we can't identify, it could be a DSL
-          node.each_ancestor(:block).any? do |ancestor|
-            !ancestor.method?(:class_eval) && !ancestor.class_constructor?
-          end
-        end
-
         def source_location(node)
           range = node.source_range
           path = smart_path(range.source_buffer.name)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for duplicate elements in Regexp character classes.
+      # Checks for duplicate elements in `Regexp` character classes.
       #
       # @example
       #