rubocop 0.93.1 → 1.79.2

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

@@ -3,7 +3,36 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for calls to debugger or pry.
+      # Checks for debug calls (such as `debugger` or `binding.pry`) that should
+      # not be kept for production code.
+      #
+      # The cop can be configured using `DebuggerMethods`. By default, a number of gems
+      # debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `debug.rb`,
+      # `Pry`, `Rails`, `RubyJard`, and `WebConsole`). Additional methods can be added.
+      #
+      # Specific default groups can be disabled if necessary:
+      #
+      # [source,yaml]
+      # ----
+      # Lint/Debugger:
+      #   DebuggerMethods:
+      #     WebConsole: ~
+      # ----
+      #
+      # You can also add your own methods by adding a new category:
+      #
+      # [source,yaml]
+      # ----
+      # Lint/Debugger:
+      #   DebuggerMethods:
+      #     MyDebugger:
+      #       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
       #
@@ -15,8 +44,6 @@ module RuboCop
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # bad (ok during development)
       #
       #   # using byebug
@@ -25,46 +52,33 @@ module RuboCop
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   def some_method
       #     do_something
       #   end
+      #
+      # @example DebuggerMethods: [my_debugger]
+      #
+      #   # bad (ok during development)
+      #
+      #   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`.'
-
-        RESTRICT_ON_SEND = %i[
-          debugger byebug remote_byebug pry remote_pry pry_remote console rescue
-          save_and_open_page save_and_open_screenshot save_screenshot irb
-        ].freeze
-
-        def_node_matcher :kernel?, <<~PATTERN
-          {
-            (const nil? :Kernel)
-            (const (cbase) :Kernel)
-          }
-        PATTERN
-
-        def_node_matcher :debugger_call?, <<~PATTERN
-          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
-           (send (send {#kernel? nil?} :binding)
-             {:pry :remote_pry :pry_remote :console} ...)
-           (send (const {nil? (cbase)} :Pry) :rescue ...)
-           (send nil? {:save_and_open_page
-                      :save_and_open_screenshot
-                      :save_screenshot} ...)}
-        PATTERN
-
-        def_node_matcher :binding_irb_call?, <<~PATTERN
-          (send (send {#kernel? nil?} :binding) :irb ...)
-        PATTERN
+        BLOCK_TYPES = %i[block numblock itblock kwbegin].freeze
 
         def on_send(node)
-          return unless debugger_call?(node) || binding_irb?(node)
+          return if assumed_usage_context?(node)
 
-          add_offense(node)
+          add_offense(node) if debugger_method?(node) || debugger_require?(node)
         end
 
         private
@@ -73,8 +87,58 @@ module RuboCop
           format(MSG, source: node.source)
         end
 
-        def binding_irb?(node)
-          binding_irb_call?(node)
+        def debugger_methods
+          @debugger_methods ||= begin
+            config = cop_config.fetch('DebuggerMethods', [])
+            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)
+          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_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)
+
+          node.each_ancestor.none? do |ancestor|
+            ancestor.type?(:any_block, :kwbegin) || ancestor.lambda_or_proc?
+          end
+        end
+
+        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
+            chained_method_name = "#{name}.#{chained_method_name}"
+            receiver = receiver.receiver
+          end
+          chained_method_name
+        end
+
+        def assumed_argument?(node)
+          parent = node.parent
+
+          parent.call_type? || parent.literal? || parent.pair_type?
         end
       end
     end

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

@@ -3,105 +3,115 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for uses of the deprecated class method usages.
+      # Checks for uses of the deprecated class method usages.
       #
       # @example
       #
       #   # bad
-      #
       #   File.exists?(some_path)
       #   Dir.exists?(some_path)
       #   iterator?
-      #
-      # @example
+      #   attr :name, true
+      #   attr :name, false
+      #   ENV.freeze # Calling `Env.freeze` raises `TypeError` since Ruby 2.7.
+      #   ENV.clone
+      #   ENV.dup # Calling `Env.dup` raises `TypeError` since Ruby 3.1.
+      #   Socket.gethostbyname(host)
+      #   Socket.gethostbyaddr(host)
       #
       #   # good
-      #
       #   File.exist?(some_path)
       #   Dir.exist?(some_path)
       #   block_given?
+      #   attr_accessor :name
+      #   attr_reader :name
+      #   ENV # `ENV.freeze` cannot prohibit changes to environment variables.
+      #   ENV.to_h
+      #   ENV.to_h # `ENV.dup` cannot dup `ENV`, use `ENV.to_h` to get a copy of `ENV` as a hash.
+      #   Addrinfo.getaddrinfo(nodename, service)
+      #   Addrinfo.tcp(host, port).getnameinfo
       class DeprecatedClassMethods < Base
         extend AutoCorrector
 
-        # Inner class to DeprecatedClassMethods.
-        # This class exists to add abstraction and clean naming to the
-        # objects that are going to be operated on.
-        class DeprecatedClassMethod
-          include RuboCop::AST::Sexp
+        MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'
+        RESTRICT_ON_SEND = %i[
+          attr clone dup exists? freeze gethostbyaddr gethostbyname iterator?
+        ].freeze
 
-          attr_reader :class_constant, :deprecated_method, :replacement_method
+        PREFERRED_METHODS = {
+          clone: 'to_h',
+          dup: 'to_h',
+          exists?: 'exist?',
+          gethostbyaddr: 'Addrinfo#getnameinfo',
+          gethostbyname: 'Addrinfo.getaddrinfo',
+          iterator?: 'block_given?'
+        }.freeze
 
-          def initialize(deprecated:, replacement:, class_constant: nil)
-            @deprecated_method = deprecated
-            @replacement_method = replacement
-            @class_constant = class_constant
-          end
+        DIR_ENV_FILE_CONSTANTS = %i[Dir ENV File].freeze
 
-          def class_nodes
-            @class_nodes ||=
-              if class_constant
-                [
-                  s(:const, nil, class_constant),
-                  s(:const, s(:cbase), class_constant)
-                ]
-              else
-                [nil]
-              end
-          end
-        end
+        # @!method deprecated_class_method?(node)
+        def_node_matcher :deprecated_class_method?, <<~PATTERN
+          {
+            (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)
+            (send nil? :iterator?)
+          }
+        PATTERN
 
-        MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'
-        DEPRECATED_METHODS_OBJECT = [
-          DeprecatedClassMethod.new(deprecated: :exists?,
-                                    replacement: :exist?,
-                                    class_constant: :File),
-          DeprecatedClassMethod.new(deprecated: :exists?,
-                                    replacement: :exist?,
-                                    class_constant: :Dir),
-          DeprecatedClassMethod.new(deprecated: :iterator?,
-                                    replacement: :block_given?)
-        ].freeze
+        def on_send(node)
+          return unless deprecated_class_method?(node)
 
-        RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.map(&:deprecated_method).freeze
+          offense_range = offense_range(node)
+          prefer = preferred_method(node)
+          message = format(MSG, current: offense_range.source, prefer: prefer)
 
-        def on_send(node)
-          check(node) do |data|
-            message = format(MSG, current: deprecated_method(data),
-                                  prefer: replacement_method(data))
+          add_offense(offense_range, message: message) do |corrector|
+            next if socket_const?(node.receiver)
 
-            add_offense(node.loc.selector, message: message) do |corrector|
-              corrector.replace(node.loc.selector, data.replacement_method.to_s)
+            if node.method?(:freeze)
+              corrector.replace(node, 'ENV')
+            else
+              corrector.replace(offense_range, prefer)
             end
           end
         end
 
         private
 
-        def check(node)
-          DEPRECATED_METHODS_OBJECT.each do |data|
-            next unless data.class_nodes.include?(node.receiver)
-            next unless node.method?(data.deprecated_method)
-
-            yield data
+        def offense_range(node)
+          if socket_const?(node.receiver) || dir_env_file_const?(node.receiver)
+            node.source_range.begin.join(node.loc.selector.end)
+          elsif node.method?(:attr)
+            node
+          else
+            node.loc.selector
           end
         end
 
-        def deprecated_method(data)
-          method_call(data.class_constant, data.deprecated_method)
-        end
+        def preferred_method(node)
+          if node.method?(:attr)
+            boolean_argument = node.arguments[1].source
+            preferred_attr_method = boolean_argument == 'true' ? 'attr_accessor' : 'attr_reader'
 
-        def replacement_method(data)
-          method_call(data.class_constant, data.replacement_method)
-        end
+            "#{preferred_attr_method} #{node.first_argument.source}"
+          elsif dir_env_file_const?(node.receiver)
+            prefer = PREFERRED_METHODS[node.method_name]
 
-        def method_call(class_constant, method)
-          if class_constant
-            format('%<constant>s.%<method>s', constant: class_constant,
-                                              method: method)
+            prefer ? "#{node.receiver.source}.#{prefer}" : 'ENV'
           else
-            format('%<method>s', method: method)
+            PREFERRED_METHODS[node.method_name]
           end
         end
+
+        def socket_const?(node)
+          node&.short_name == :Socket
+        end
+
+        def dir_env_file_const?(node)
+          DIR_ENV_FILE_CONSTANTS.include?(node&.short_name)
+        end
       end
     end
   end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for deprecated constants.
+      #
+      # It has `DeprecatedConstants` config. If there is an alternative method, you can set
+      # alternative value as `Alternative`. And you can set the deprecated version as
+      # `DeprecatedVersion`. These options can be omitted if they are not needed.
+      #
+      #   DeprecatedConstants:
+      #     'DEPRECATED_CONSTANT':
+      #       Alternative: 'alternative_value'
+      #       DeprecatedVersion: 'deprecated_version'
+      #
+      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException, `Random::DEFAULT`,
+      # `Struct::Group`, and `Struct::Passwd` are configured.
+      #
+      # @example
+      #
+      #   # bad
+      #   NIL
+      #   TRUE
+      #   FALSE
+      #   Net::HTTPServerException
+      #   Random::DEFAULT # Return value of Ruby 2 is `Random` instance, Ruby 3.0 is `Random` class.
+      #   Struct::Group
+      #   Struct::Passwd
+      #
+      #   # good
+      #   nil
+      #   true
+      #   false
+      #   Net::HTTPClientException
+      #   Random.new # `::DEFAULT` has been deprecated in Ruby 3, `.new` is compatible with Ruby 2.
+      #   Etc::Group
+      #   Etc::Passwd
+      #
+      class DeprecatedConstants < Base
+        extend AutoCorrector
+
+        SUGGEST_GOOD_MSG = 'Use `%<good>s` instead of `%<bad>s`%<deprecated_message>s.'
+        DO_NOT_USE_MSG = 'Do not use `%<bad>s`%<deprecated_message>s.'
+
+        def on_const(node)
+          # FIXME: Workaround for "`undefined method `expression' for nil:NilClass`" when processing
+          #        `__ENCODING__`. It is better to be able to work without this condition.
+          #        Maybe further investigation of RuboCop AST will lead to an essential solution.
+          return unless node.loc
+
+          constant = node.absolute? ? constant_name(node, node.short_name) : node.source
+          return unless (deprecated_constant = deprecated_constants[constant])
+
+          alternative = deprecated_constant['Alternative']
+          version = deprecated_constant['DeprecatedVersion']
+          return if target_ruby_version < version.to_f
+
+          add_offense(node, message: message(alternative, node.source, version)) do |corrector|
+            corrector.replace(node, alternative)
+          end
+        end
+
+        private
+
+        def constant_name(node, nested_constant_name)
+          return nested_constant_name.to_s unless node.namespace.const_type?
+
+          constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
+        end
+
+        def message(good, bad, deprecated_version)
+          deprecated_message = ", deprecated since Ruby #{deprecated_version}" if deprecated_version
+
+          if good
+            format(SUGGEST_GOOD_MSG, good: good, bad: bad, deprecated_message: deprecated_message)
+          else
+            format(DO_NOT_USE_MSG, bad: bad, deprecated_message: deprecated_message)
+          end
+        end
+
+        def deprecated_constants
+          cop_config.fetch('DeprecatedConstants', {})
+        end
+      end
+    end
+  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')
       #
@@ -41,9 +31,12 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)`' \
-          ' instead of `%<original>s`.'
+        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)
         def_node_matcher :algorithm_const, <<~PATTERN
           (send
             $(const
@@ -53,15 +46,19 @@ module RuboCop
             ...)
         PATTERN
 
+        # @!method digest_const?(node)
+        def_node_matcher :digest_const?, <<~PATTERN
+          (const _ :Digest)
+        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)
 
           message = message(node)
 
-          add_offense(node, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
 
         private
@@ -94,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)
@@ -104,7 +101,7 @@ module RuboCop
         def algorithm_name(node)
           name = node.loc.name.source
 
-          if openssl_class(node) == 'OpenSSL::Cipher'
+          if openssl_class(node) == 'OpenSSL::Cipher' && !NO_ARG_ALGORITHM.include?(name)
             name.scan(/.{3}/).join('-')
           else
             name
@@ -124,16 +121,23 @@ module RuboCop
           algorithm_name = algorithm_name(algorithm_constant)
 
           if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
-            build_cipher_arguments(node, algorithm_name)
+            build_cipher_arguments(node, algorithm_name, node.arguments.empty?)
           else
             (["'#{algorithm_name}'"] + node.arguments.map(&:source)).join(', ')
           end
         end
 
-        def build_cipher_arguments(node, algorithm_name)
+        def build_cipher_arguments(node, algorithm_name, no_arguments)
           algorithm_parts = algorithm_name.downcase.split('-')
           size_and_mode = sanitize_arguments(node.arguments).map(&:downcase)
-          "'#{(algorithm_parts + size_and_mode + ['cbc']).take(3).join('-')}'"
+
+          if NO_ARG_ALGORITHM.include?(algorithm_parts.first.upcase) && no_arguments
+            "'#{algorithm_parts.first}'"
+          else
+            mode = 'cbc' if size_and_mode.empty?
+
+            "'#{(algorithm_parts + size_and_mode + [mode]).compact.take(3).join('-')}'"
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks constructors for disjunctive assignments that should
+      # Checks constructors for disjunctive assignments (`||=`) that should
       # be plain assignments.
       #
       # So far, this cop is only concerned with disjunctive assignment of
@@ -12,6 +12,29 @@ module RuboCop
       # In ruby, an instance variable is nil until a value is assigned, so the
       # disjunction is unnecessary. A plain assignment has the same effect.
       #
+      # @safety
+      #   This cop is unsafe because it can register a false positive when a
+      #   method is redefined in a subclass that calls super. For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Base
+      #     def initialize
+      #       @config ||= 'base'
+      #     end
+      #   end
+      #
+      #   class Derived < Base
+      #     def initialize
+      #       @config = 'derived'
+      #       super
+      #     end
+      #   end
+      #   ----
+      #
+      #   Without the disjunctive assignment, `Derived` will be unable to override
+      #   the value for `@config`.
+      #
       # @example
       #   # bad
       #   def initialize