rubocop 1.22.0 → 1.45.1

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

@@ -3,146 +3,114 @@
 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?
+      #   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)
       #
-      # @example
-      #
       #   # 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 deprecated objects
-        class DeprecatedClassMethod
-          include RuboCop::AST::Sexp
-
-          attr_reader :method, :class_constant
+        MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'
+        RESTRICT_ON_SEND = %i[
+          attr clone dup exists? freeze gethostbyaddr gethostbyname iterator?
+        ].freeze
+
+        PREFERRED_METHDOS = {
+          clone: 'to_h',
+          dup: 'to_h',
+          exists?: 'exist?',
+          gethostbyaddr: 'Addrinfo#getnameinfo',
+          gethostbyname: 'Addrinfo#getaddrinfo',
+          iterator?: 'block_given?'
+        }.freeze
 
-          def initialize(method, class_constant: nil, correctable: true)
-            @method = method
-            @class_constant = class_constant
-            @correctable = correctable
-          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
+        # @!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
 
-          def correctable?
-            @correctable
-          end
+        def on_send(node)
+          return unless deprecated_class_method?(node)
 
-          def to_s
-            [class_constant, method].compact.join(delimiter)
-          end
+          offense_range = offense_range(node)
+          prefer = preferred_method(node)
+          message = format(MSG, current: offense_range.source, prefer: prefer)
 
-          private
+          add_offense(offense_range, message: message) do |corrector|
+            next if socket_const?(node.receiver)
 
-          def delimiter
-            CLASS_METHOD_DELIMETER
+            if node.method?(:freeze)
+              corrector.replace(node, 'ENV')
+            else
+              corrector.replace(offense_range, prefer)
+            end
           end
         end
 
-        # Inner class to DeprecatedClassMethods.
-        # This class exists to add abstraction and clean naming
-        # to the replacements for deprecated objects
-        class Replacement
-          attr_reader :method, :class_constant
-
-          def initialize(method, class_constant: nil, instance_method: false)
-            @method = method
-            @class_constant = class_constant
-            @instance_method = instance_method
-          end
-
-          def to_s
-            [class_constant, method].compact.join(delimiter)
-          end
-
-          private
-
-          def delimiter
-            instance_method? ? INSTANCE_METHOD_DELIMETER : CLASS_METHOD_DELIMETER
-          end
+        private
 
-          def instance_method?
-            @instance_method
+        def offense_range(node)
+          if socket_const?(node.receiver) || dir_env_file_const?(node.receiver)
+            node.loc.expression.begin.join(node.loc.selector.end)
+          elsif node.method?(:attr)
+            node
+          else
+            node.loc.selector
           end
         end
 
-        MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'
-
-        DEPRECATED_METHODS_OBJECT = {
-          DeprecatedClassMethod.new(:exists?, class_constant: :File) =>
-            Replacement.new(:exist?, class_constant: :File),
-
-          DeprecatedClassMethod.new(:exists?, class_constant: :Dir) =>
-            Replacement.new(:exist?, class_constant: :Dir),
-
-          DeprecatedClassMethod.new(:iterator?) => Replacement.new(:block_given?),
-
-          DeprecatedClassMethod.new(:gethostbyaddr, class_constant: :Socket, correctable: false) =>
-            Replacement.new(:getnameinfo, class_constant: :Addrinfo, instance_method: true),
-
-          DeprecatedClassMethod.new(:gethostbyname, class_constant: :Socket, correctable: false) =>
-            Replacement.new(:getaddrinfo, class_constant: :Addrinfo, instance_method: true)
-        }.freeze
-
-        RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.keys.map(&:method).freeze
+        def preferred_method(node)
+          if node.method?(:attr)
+            boolean_argument = node.arguments[1].source
+            preferred_attr_method = boolean_argument == 'true' ? 'attr_accessor' : 'attr_reader'
 
-        CLASS_METHOD_DELIMETER = '.'
-        INSTANCE_METHOD_DELIMETER = '#'
+            "#{preferred_attr_method} #{node.first_argument.source}"
+          elsif dir_env_file_const?(node.receiver)
+            prefer = PREFERRED_METHDOS[node.method_name]
 
-        def on_send(node)
-          check(node) do |deprecated|
-            message = format(MSG, current: deprecated, prefer: replacement(deprecated))
-
-            add_offense(node.loc.selector, message: message) do |corrector|
-              if deprecated.correctable?
-                corrector.replace(node.loc.selector, replacement(deprecated).method)
-              end
-            end
+            prefer ? "#{node.receiver.source}.#{prefer}" : 'ENV'
+          else
+            PREFERRED_METHDOS[node.method_name]
           end
         end
 
-        private
-
-        def check(node)
-          DEPRECATED_METHODS_OBJECT.each_key do |deprecated|
-            next unless deprecated.class_nodes.include?(node.receiver)
-            next unless node.method?(deprecated.method)
-
-            yield deprecated
-          end
+        def socket_const?(node)
+          node&.short_name == :Socket
         end
 
-        def replacement(deprecated)
-          DEPRECATED_METHODS_OBJECT[deprecated]
+        def dir_env_file_const?(node)
+          DIR_ENV_FILE_CONSTANTS.include?(node&.short_name)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for deprecated constants.
+      # 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
@@ -14,7 +14,8 @@ module RuboCop
       #       Alternative: 'alternative_value'
       #       DeprecatedVersion: 'deprecated_version'
       #
-      # By default, `NIL`, `TRUE`, `FALSE` and `Random::DEFAULT` are configured.
+      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException, `Random::DEFAULT`,
+      # `Struct::Group`, and `Struct::Passwd` are configured.
       #
       # @example
       #
@@ -22,13 +23,19 @@ module RuboCop
       #   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
@@ -42,11 +49,12 @@ module RuboCop
           #        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.to_s) : node.source
+          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)
@@ -56,7 +64,7 @@ module RuboCop
         private
 
         def constant_name(node, nested_constant_name)
-          return nested_constant_name unless node.namespace.const_type?
+          return nested_constant_name.to_s unless node.namespace.const_type?
 
           constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
         end

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

@@ -55,8 +55,14 @@ 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 digest_const?(node.receiver)
           return unless algorithm_const(node)
 
           message = message(node)

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

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks that there are no repeated bodies
+      # Checks that there are no repeated bodies
       # within `if/unless`, `case-when`, `case-in` and `rescue` constructs.
       #
       # With `IgnoreLiteralBranches: true`, branches are not registered
@@ -84,8 +84,6 @@ module RuboCop
       #   end
       #
       class DuplicateBranch < Base
-        include RescueNode
-
         MSG = 'Duplicate branch body detected.'
 
         def on_branching_statement(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks that there are no repeated conditions
+      # Checks that there are no repeated conditions
       # used in case 'when' expressions.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks that there are no repeated conditions used in if 'elsif'.
+      # Checks that there are no repeated conditions used in if 'elsif'.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for duplicated keys in hash literals.
+      # Checks for duplicated keys in hash literals.
       #
       # This cop mirrors a warning in Ruby 2.2.
       #

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for duplicated magic comments.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # encoding: ascii
+      #   # encoding: ascii
+      #
+      #   # good
+      #
+      #   # encoding: ascii
+      #
+      #   # bad
+      #
+      #   # frozen_string_literal: true
+      #   # frozen_string_literal: true
+      #
+      #   # good
+      #
+      #   # frozen_string_literal: true
+      #
+      class DuplicateMagicComment < Base
+        include FrozenStringLiteral
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Duplicate magic comment detected.'
+
+        def on_new_investigation
+          return if processed_source.buffer.source.empty?
+
+          magic_comment_lines.each_value do |comment_lines|
+            next if comment_lines.count <= 1
+
+            comment_lines[1..].each do |comment_line|
+              range = processed_source.buffer.line_range(comment_line + 1)
+
+              register_offense(range)
+            end
+          end
+        end
+
+        private
+
+        def magic_comment_lines
+          comment_lines = { encoding_magic_comments: [], frozen_string_literal_magic_comments: [] }
+
+          leading_magic_comments.each.with_index do |magic_comment, index|
+            if magic_comment.encoding_specified?
+              comment_lines[:encoding_magic_comments] << index
+            elsif magic_comment.frozen_string_literal_specified?
+              comment_lines[:frozen_string_literal_magic_comments] << index
+            end
+          end
+
+          comment_lines
+        end
+
+        def register_offense(range)
+          add_offense(range) do |corrector|
+            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for duplicated instance (or singleton) method
+      # Checks for duplicated instance (or singleton) method
       # definitions.
       #
       # @example
@@ -51,25 +51,26 @@ module RuboCop
       #   alias bar foo
       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
 
         def initialize(config = nil, options = nil)
           super
           @definitions = {}
+          @scopes = Hash.new { |hash, key| hash[key] = [] }
         end
 
         def on_def(node)
           # 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.ancestors.any?(&:if_type?)
+          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.ancestors.any?(&:if_type?)
+          return if node.each_ancestor.any?(&:if_type?)
           return if possible_dsl?(node)
 
           if node.receiver.const_type?
@@ -127,13 +128,13 @@ module RuboCop
           found_method(node, "#{enclosing}.#{name}")
         end
 
-        def message_for_dup(node, method_name)
-          format(MSG, method: method_name, defined: source_location(@definitions[method_name]),
+        def message_for_dup(node, method_name, key)
+          format(MSG, method: method_name, defined: source_location(@definitions[key]),
                       current: source_location(node))
         end
 
         def found_instance_method(node, name)
-          return unless (scope = node.parent_module_name)
+          return found_sclass_method(node, name) unless (scope = node.parent_module_name)
 
           # Humanize the scope
           scope = scope.sub(
@@ -145,19 +146,48 @@ module RuboCop
           found_method(node, "#{scope}#{name}")
         end
 
+        def found_sclass_method(node, name)
+          singleton_ancestor = node.each_ancestor.find(&:sclass_type?)
+          return unless singleton_ancestor
+
+          singleton_receiver_node = singleton_ancestor.children[0]
+          return unless singleton_receiver_node.send_type?
+
+          found_method(node, "#{singleton_receiver_node.method_name}.#{name}")
+        end
+
         def found_method(node, method_name)
-          if @definitions.key?(method_name)
-            loc = case node.type
-                  when :def, :defs
-                    node.loc.keyword.join(node.loc.name)
-                  else
-                    node.loc.expression
-                  end
-            message = message_for_dup(node, method_name)
-
-            add_offense(loc, message: message)
+          key = method_key(node, method_name)
+          scope = node.each_ancestor(:rescue, :ensure).first&.type
+
+          if @definitions.key?(key)
+            if scope && !@scopes[scope].include?(key)
+              @definitions[key] = node
+              @scopes[scope] << key
+              return
+            end
+
+            message = message_for_dup(node, method_name, key)
+
+            add_offense(location(node), message: message)
+          else
+            @definitions[key] = node
+          end
+        end
+
+        def method_key(node, method_name)
+          if (ancestor_def = node.each_ancestor(*DEF_TYPES).first)
+            "#{ancestor_def.method_name}.#{method_name}"
+          else
+            method_name
+          end
+        end
+
+        def location(node)
+          if DEF_TYPES.include?(node.type)
+            node.loc.keyword.join(node.loc.name)
           else
-            @definitions[method_name] = node
+            node.loc.expression
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for duplicate elements in Regexp character classes.
+      # Checks for duplicate elements in Regexp character classes.
       #
       # @example
       #
@@ -32,26 +32,40 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def each_repeated_character_class_element_loc(node)
           node.parsed_tree&.each_expression do |expr|
-            next if expr.type != :set || expr.token == :intersection
+            next if skip_expression?(expr)
 
             seen = Set.new
+            enum = expr.expressions.to_enum
+            expression_count = expr.expressions.count
 
-            expr.expressions.each do |child|
-              next if within_interpolation?(node, child)
+            expression_count.times do |current_number|
+              current_child = enum.next
+              next if within_interpolation?(node, current_child)
 
-              child_source = child.to_s
+              current_child_source = current_child.to_s
+              next_child = enum.peek if current_number + 1 < expression_count
 
-              yield child.expression if seen.include?(child_source)
+              if seen.include?(current_child_source)
+                next if start_with_escaped_zero_number?(current_child_source, next_child.to_s)
 
-              seen << child_source
+                yield current_child.expression
+              end
+
+              seen << current_child_source
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         private
 
+        def skip_expression?(expr)
+          expr.type != :set || expr.token == :intersection
+        end
+
         # Since we blank interpolations with a space for every char of the interpolation, we would
         # mark every space (except the first) as duplicate if we do not skip regexp_parser nodes
         # that are within an interpolation.
@@ -61,6 +75,11 @@ module RuboCop
           interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
         end
 
+        def start_with_escaped_zero_number?(current_child, next_child)
+          # Represents escaped code from `"\00"` (`"\u0000"`) to `"\07"` (`"\a"`).
+          current_child == '\\0' && next_child.match?(/[0-7]/)
+        end
+
         def interpolation_locs(node)
           @interpolation_locs ||= {}
 

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

@@ -3,7 +3,11 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for duplicate `require`s and `require_relative`s.
+      # Checks for duplicate ``require``s and ``require_relative``s.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may break the dependency order
+      #   of `require`.
       #
       # @example
       #   # bad
@@ -20,6 +24,9 @@ module RuboCop
       #   require_relative 'foo'
       #
       class DuplicateRequire < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Duplicate `%<method>s` detected.'
         REQUIRE_METHODS = Set.new(%i[require require_relative]).freeze
         RESTRICT_ON_SEND = REQUIRE_METHODS
@@ -39,7 +46,9 @@ module RuboCop
           return unless require_call?(node)
           return if @required[node.parent].add?("#{node.method_name}#{node.first_argument}")
 
-          add_offense(node, message: format(MSG, method: node.method_name))
+          add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks that there are no repeated exceptions
+      # Checks that there are no repeated exceptions
       # used in 'rescue' expressions.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks if each_with_object is called with an immutable
+      # Checks if each_with_object is called with an immutable
       # argument. Since the argument is the object that the given block shall
       # make calls on to build something based on the enumerable that
       # each_with_object iterates over, an immutable argument makes no sense.
@@ -27,7 +27,7 @@ module RuboCop
 
         # @!method each_with_object?(node)
         def_node_matcher :each_with_object?, <<~PATTERN
-          ({send csend} _ :each_with_object $_)
+          (call _ :each_with_object $_)
         PATTERN
 
         def on_send(node)