rubocop 1.53.0 → 1.90.0

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)
 
@@ -127,8 +118,11 @@ module RuboCop
 
         def replacement_args(node)
           algorithm_constant, = algorithm_const(node)
-          algorithm_name = algorithm_name(algorithm_constant)
+          if algorithm_constant.source == 'OpenSSL::Cipher::Cipher'
+            return node.first_argument.source
+          end
 
+          algorithm_name = algorithm_name(algorithm_constant)
           if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
             build_cipher_arguments(node, algorithm_name, node.arguments.empty?)
           else
@@ -143,7 +137,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/deprecated_reference.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for calls to methods and references to constants that are documented
+      # as deprecated with a YARD `@deprecated` tag.
+      #
+      # The check is powered by the project-wide index, so it only runs when
+      # `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed.
+      # Without the index the cop does nothing.
+      #
+      # Only references that can be resolved without type inference are checked:
+      # constants, method calls without an explicit receiver (or with `self`),
+      # which are looked up in the enclosing class or module and its ancestry,
+      # and calls whose receiver is a constant, which are looked up in that
+      # namespace's singleton class. Calls on arbitrary objects are not checked.
+      #
+      # References made from a definition that is itself deprecated are allowed,
+      # so deprecated implementations can keep calling each other.
+      #
+      # @example
+      #   # Given a deprecated method and constant:
+      #   #
+      #   #   class Api
+      #   #     # @deprecated Use `#new_method` instead.
+      #   #     def old_method
+      #   #     end
+      #   #
+      #   #     # @deprecated
+      #   #     OLD_TIMEOUT = 10
+      #   #   end
+      #
+      #   # bad
+      #   class Client < Api
+      #     def call
+      #       old_method
+      #     end
+      #
+      #     def timeout
+      #       OLD_TIMEOUT
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Client < Api
+      #     def call
+      #       new_method
+      #     end
+      #
+      #     def timeout
+      #       NEW_TIMEOUT
+      #     end
+      #   end
+      #
+      class DeprecatedReference < Base
+        include ProjectIndexHelp
+
+        METHOD_MSG = 'Method `%<name>s` is deprecated%<detail>s'
+        CONSTANT_MSG = 'Constant `%<name>s` is deprecated%<detail>s'
+
+        DEPRECATED_TAG = '@deprecated'
+        DEPRECATION_DETAIL = /#{DEPRECATED_TAG}\s+(.+)/.freeze
+
+        def on_new_investigation
+          @namespace_cache = {}
+          super
+        end
+
+        def on_send(node)
+          return unless project_index
+
+          declaration = method_declaration_for(node)
+          return unless declaration && deprecated?(declaration)
+          return if within_deprecated_definition?(node)
+
+          message = format(METHOD_MSG, name: node.method_name, detail: detail_for(declaration))
+          add_offense(node.loc.selector, message: message)
+        end
+        alias on_csend on_send
+
+        def on_const(node)
+          return unless project_index
+          return if node.parent&.defined_module
+
+          declaration = resolve_constant_in_index(node)
+          return unless declaration && deprecated?(declaration)
+          return if within_deprecated_definition?(node)
+
+          message = format(CONSTANT_MSG, name: node.const_name, detail: detail_for(declaration))
+          add_offense(node, message: message)
+        end
+
+        private
+
+        def method_declaration_for(node)
+          receiver = node.receiver
+
+          if receiver.nil? || receiver.self_type?
+            implicit_receiver_declaration(node)
+          elsif receiver.const_type?
+            const_receiver_declaration(node, receiver)
+          end
+        end
+
+        def implicit_receiver_declaration(node)
+          namespace = enclosing_namespace(node)
+          return nil unless namespace.is_a?(Rubydex::Namespace)
+
+          if singleton_context?(node)
+            indexed_singleton_member(namespace, "#{node.method_name}()")
+          else
+            namespace.find_member("#{node.method_name}()")
+          end
+        end
+
+        def const_receiver_declaration(node, receiver)
+          namespace = resolve_constant_in_index(receiver)
+          return nil unless namespace.is_a?(Rubydex::Namespace)
+
+          indexed_singleton_member(namespace, "#{node.method_name}()")
+        end
+
+        def enclosing_namespace(node)
+          namespace_node = node.each_ancestor(:class, :module).first
+          return project_index['Object'] unless namespace_node
+
+          @namespace_cache.fetch(namespace_node) do
+            @namespace_cache[namespace_node] = resolve_constant_in_index(namespace_node.identifier)
+          end
+        end
+
+        # Whether an implicit-receiver call runs with the class or module itself
+        # as `self` (directly in a namespace body, in a singleton method, or
+        # inside `class << self`) rather than inside an instance method.
+        def singleton_context?(node)
+          instance_def_seen = false
+
+          node.each_ancestor do |ancestor|
+            case ancestor.type
+            when :defs, :sclass
+              return true
+            when :def
+              instance_def_seen = true
+            when :class, :module
+              return !instance_def_seen
+            end
+          end
+
+          false
+        end
+
+        # Enumerated in a single pass that stops at the first non-deprecated
+        # definition, since materializing every definition of a declaration
+        # that is almost never deprecated dominates the cop's cost.
+        def deprecated?(declaration)
+          any = false
+
+          declaration.definitions.each do |definition|
+            return false unless definition.deprecated?
+
+            any = true
+          end
+
+          any
+        end
+
+        # References from a definition that is itself documented as deprecated
+        # are allowed.
+        def within_deprecated_definition?(node)
+          node.each_ancestor(:any_def, :class, :module).any? do |ancestor|
+            comments = processed_source.ast_with_comments[ancestor]
+            comments.any? { |comment| comment.text.include?(DEPRECATED_TAG) }
+          end
+        end
+
+        def detail_for(declaration)
+          text = deprecation_text(declaration)
+          return '.' if text.nil? || text.empty?
+
+          text.end_with?('.') ? ": #{text}" : ": #{text}."
+        end
+
+        def deprecation_text(declaration)
+          tag_comment = declaration.definitions.to_a.filter_map do |definition|
+            definition.comments.to_a.map(&:string).find { |string| string.include?(DEPRECATED_TAG) }
+          end.first
+
+          tag_comment && tag_comment[DEPRECATION_DETAIL, 1]&.strip
+        end
+      end
+    end
+  end
+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

@@ -11,13 +11,9 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   hash = { food: 'apple', food: 'orange' }
       #
-      # @example
-      #
       #   # good
-      #
       #   hash = { food: 'apple', other_food: 'orange' }
       class DuplicateHashKey < Base
         include Duplication

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

@@ -25,17 +25,17 @@ module RuboCop
       #
       #   # bad - repeated alternate patterns with the same conditions don't depend on the order
       #   case x
-      #   in foo | bar
+      #   in 0 | 1
       #     first_method
-      #   in bar | foo
+      #   in 1 | 0
       #     second_method
       #   end
       #
       #   # good
       #   case x
-      #   in foo | bar
+      #   in 0 | 1
       #     first_method
-      #   in bar | baz
+      #   in 2 | 3
       #     second_method
       #   end
       #
@@ -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