rubocop 1.44.1 → 1.78.0

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

@@ -29,6 +29,11 @@ module RuboCop
       #       MyDebugger.debug_this
       # ----
       #
+      # Some gems also ship files that will start a debugging session when required,
+      # for example `require 'debug/start'` from `ruby/debug`. These requires can
+      # be configured through `DebuggerRequires`. It has the same structure as
+      # `DebuggerMethods`, which you can read about above.
+      #
       # @example
       #
       #   # bad (ok during development)
@@ -39,8 +44,6 @@ module RuboCop
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # bad (ok during development)
       #
       #   # using byebug
@@ -49,8 +52,6 @@ module RuboCop
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   def some_method
@@ -64,13 +65,20 @@ module RuboCop
       #   def some_method
       #     my_debugger
       #   end
+      #
+      # @example DebuggerRequires: [my_debugger/start]
+      #
+      #   # bad (ok during development)
+      #
+      #   require 'my_debugger/start'
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
+        BLOCK_TYPES = %i[block numblock itblock kwbegin].freeze
 
         def on_send(node)
-          return unless debugger_method?(node)
+          return if assumed_usage_context?(node)
 
-          add_offense(node)
+          add_offense(node) if debugger_method?(node) || debugger_require?(node)
         end
 
         private
@@ -82,44 +90,55 @@ module RuboCop
         def debugger_methods
           @debugger_methods ||= begin
             config = cop_config.fetch('DebuggerMethods', [])
-            values = config.is_a?(Array) ? config : config.values.flatten
-            values.map do |v|
-              next unless v
-
-              *receiver, method_name = v.split('.')
-              {
-                receiver: receiver.empty? ? nil : receiver.map(&:to_sym),
-                method_name: method_name.to_sym
-              }
-            end.compact
+            config.is_a?(Array) ? config : config.values.flatten
+          end
+        end
+
+        def debugger_requires
+          @debugger_requires ||= begin
+            config = cop_config.fetch('DebuggerRequires', [])
+            config.is_a?(Array) ? config : config.values.flatten
           end
         end
 
         def debugger_method?(send_node)
-          method_name = send_node.method_name
+          return false if send_node.parent&.send_type? && send_node.parent.receiver == send_node
+
+          debugger_methods.include?(chained_method_name(send_node))
+        end
+
+        def debugger_require?(send_node)
+          return false unless send_node.method?(:require) && send_node.arguments.one?
+          return false unless (argument = send_node.first_argument).str_type?
 
-          debugger_methods.any? do |method|
-            next unless method[:method_name] == method_name
+          debugger_requires.include?(argument.value)
+        end
+
+        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(:call).any?
+          return true if assumed_argument?(node)
 
-            if method[:receiver].nil?
-              send_node.receiver.nil?
-            else
-              method[:receiver] == receiver_chain(send_node)
-            end
+          node.each_ancestor.none? do |ancestor|
+            ancestor.type?(:any_block, :kwbegin) || ancestor.lambda_or_proc?
           end
         end
 
-        def receiver_chain(send_node)
-          receivers = []
+        def chained_method_name(send_node)
+          chained_method_name = send_node.method_name.to_s
           receiver = send_node.receiver
-
           while receiver
-            name = receiver.send_type? ? receiver.method_name : receiver.const_name&.to_sym
-            receivers.unshift(name)
+            name = receiver.send_type? ? receiver.method_name : receiver.const_name
+            chained_method_name = "#{name}.#{chained_method_name}"
             receiver = receiver.receiver
           end
+          chained_method_name
+        end
+
+        def assumed_argument?(node)
+          parent = node.parent
 
-          receivers
+          parent.call_type? || parent.literal? || parent.pair_type?
         end
       end
     end

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

@@ -38,12 +38,12 @@ module RuboCop
           attr clone dup exists? freeze gethostbyaddr gethostbyname iterator?
         ].freeze
 
-        PREFERRED_METHDOS = {
+        PREFERRED_METHODS = {
           clone: 'to_h',
           dup: 'to_h',
           exists?: 'exist?',
           gethostbyaddr: 'Addrinfo#getnameinfo',
-          gethostbyname: 'Addrinfo#getaddrinfo',
+          gethostbyname: 'Addrinfo.getaddrinfo',
           iterator?: 'block_given?'
         }.freeze
 
@@ -52,7 +52,7 @@ module RuboCop
         # @!method deprecated_class_method?(node)
         def_node_matcher :deprecated_class_method?, <<~PATTERN
           {
-            (send (const {cbase nil?} {:ENV}) {:clone :dup :freeze})
+            (send (const {cbase nil?} :ENV) {:clone :dup :freeze})
             (send (const {cbase nil?} {:File :Dir}) :exists? _)
             (send (const {cbase nil?} :Socket) {:gethostbyaddr :gethostbyname} ...)
             (send nil? :attr _ boolean)
@@ -82,7 +82,7 @@ module RuboCop
 
         def offense_range(node)
           if socket_const?(node.receiver) || dir_env_file_const?(node.receiver)
-            node.loc.expression.begin.join(node.loc.selector.end)
+            node.source_range.begin.join(node.loc.selector.end)
           elsif node.method?(:attr)
             node
           else
@@ -97,11 +97,11 @@ module RuboCop
 
             "#{preferred_attr_method} #{node.first_argument.source}"
           elsif dir_env_file_const?(node.receiver)
-            prefer = PREFERRED_METHDOS[node.method_name]
+            prefer = PREFERRED_METHODS[node.method_name]
 
             prefer ? "#{node.receiver.source}.#{prefer}" : 'ENV'
           else
-            PREFERRED_METHDOS[node.method_name]
+            PREFERRED_METHODS[node.method_name]
           end
         end
 

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

@@ -9,28 +9,18 @@ module RuboCop
       #
       # @example
       #
-      #   # Example for OpenSSL::Cipher instantiation.
-      #
       #   # bad
       #   OpenSSL::Cipher::AES.new(128, :GCM)
       #
       #   # good
       #   OpenSSL::Cipher.new('aes-128-gcm')
       #
-      # @example
-      #
-      #   # Example for OpenSSL::Digest instantiation.
-      #
       #   # bad
       #   OpenSSL::Digest::SHA256.new
       #
       #   # good
       #   OpenSSL::Digest.new('SHA256')
       #
-      # @example
-      #
-      #   # Example for ::Digest inherited class methods.
-      #
       #   # bad
       #   OpenSSL::Digest::SHA256.digest('foo')
       #
@@ -43,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)
@@ -61,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)
 
@@ -100,7 +91,7 @@ module RuboCop
         end
 
         def correction_range(node)
-          range_between(node.loc.dot.end_pos, node.loc.expression.end_pos)
+          range_between(node.loc.dot.end_pos, node.source_range.end_pos)
         end
 
         def openssl_class(node)
@@ -143,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_case_condition.rb

@@ -9,7 +9,6 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   case x
       #   when 'first'
       #     do_something
@@ -17,10 +16,7 @@ module RuboCop
       #     do_something_else
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   case x
       #   when 'first'
       #     do_something
@@ -32,7 +28,7 @@ module RuboCop
 
         def on_case(case_node)
           case_node.when_branches.each_with_object(Set.new) do |when_node, previous|
-            when_node.each_condition do |condition|
+            when_node.conditions.each do |condition|
               add_offense(condition) unless previous.add?(condition)
             end
           end

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

@@ -4,19 +4,16 @@ module RuboCop
   module Cop
     module Lint
       # Checks for duplicated keys in hash literals.
+      # This cop considers both primitive types and constants for the hash keys.
       #
       # This cop mirrors a warning in Ruby 2.2.
       #
       # @example
       #
       #   # bad
-      #
       #   hash = { food: 'apple', food: 'orange' }
       #
-      # @example
-      #
       #   # good
-      #
       #   hash = { food: 'apple', other_food: 'orange' }
       class DuplicateHashKey < Base
         include Duplication
@@ -24,7 +21,7 @@ module RuboCop
         MSG = 'Duplicated key in hash literal.'
 
         def on_hash(node)
-          keys = node.keys.select(&:recursive_basic_literal?)
+          keys = node.keys.select { |key| key.recursive_basic_literal? || key.const_type? }
 
           return unless duplicates?(keys)
 

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that there are no repeated patterns used in `in` keywords.
+      #
+      # @example
+      #
+      #   # bad
+      #   case x
+      #   in 'first'
+      #     do_something
+      #   in 'first'
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in 'first'
+      #     do_something
+      #   in 'second'
+      #     do_something_else
+      #   end
+      #
+      #   # bad - repeated alternate patterns with the same conditions don't depend on the order
+      #   case x
+      #   in foo | bar
+      #     first_method
+      #   in bar | foo
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo | bar
+      #     first_method
+      #   in bar | baz
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated hash patterns with the same conditions don't depend on the order
+      #   case x
+      #   in foo: a, bar: b
+      #     first_method
+      #   in bar: b, foo: a
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo: a, bar: b
+      #     first_method
+      #   in bar: b, baz: c
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated array patterns with elements in the same order
+      #   case x
+      #   in [foo, bar]
+      #     first_method
+      #   in [foo, bar]
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in [foo, bar]
+      #     first_method
+      #   in [bar, foo]
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated the same patterns and guard conditions
+      #   case x
+      #   in foo if bar
+      #     first_method
+      #   in foo if bar
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo if bar
+      #     first_method
+      #   in foo if baz
+      #     second_method
+      #   end
+      #
+      class DuplicateMatchPattern < Base
+        extend TargetRubyVersion
+
+        MSG = 'Duplicate `in` pattern detected.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_case_match(case_node)
+          case_node.in_pattern_branches.each_with_object(Set.new) do |in_pattern_node, previous|
+            pattern = in_pattern_node.pattern
+            next if previous.add?(pattern_identity(pattern))
+
+            add_offense(pattern)
+          end
+        end
+
+        private
+
+        def pattern_identity(pattern)
+          pattern_source = if pattern.type?(:hash_pattern, :match_alt)
+                             pattern.children.map(&:source).sort.to_s
+                           else
+                             pattern.source
+                           end
+
+          return pattern_source unless (guard = pattern.parent.children[1])
+
+          pattern_source + guard.source
+        end
+      end
+    end
+  end
+end