rubocop 1.39.0 → 1.44.1

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

@@ -38,6 +38,10 @@ module RuboCop
                      'a whitespace to the right of the `%<operator>s` if it ' \
                      'should be %<possible>s.'
 
+        def self.autocorrect_incompatible_with
+          [Naming::BlockForwarding]
+        end
+
         def on_new_investigation
           processed_source.diagnostics.each do |diagnostic|
             next unless diagnostic.reason == :ambiguous_prefix

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

@@ -11,6 +11,10 @@ module RuboCop
       # an assignment to indicate "I know I'm using an assignment
       # as a condition. It's not a mistake."
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because it assumes that
+      #   the author meant to use an assignment result as a condition.
+      #
       # @example
       #   # bad
       #   if some_var = true
@@ -35,6 +39,8 @@ module RuboCop
       #   end
       #
       class AssignmentInCondition < Base
+        extend AutoCorrector
+
         include SafeAssignment
 
         MSG_WITH_SAFE_ASSIGNMENT_ALLOWED =
@@ -53,7 +59,11 @@ module RuboCop
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
 
-            add_offense(asgn_node.loc.operator)
+            add_offense(asgn_node.loc.operator) do |corrector|
+              next unless safe_assignment_allowed?
+
+              corrector.wrap(asgn_node, '(', ')')
+            end
           end
         end
         alias on_while on_if

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

@@ -16,6 +16,10 @@ module RuboCop
       # using the same name a namespace and a class. To avoid too many unnecessary
       # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
       #
+      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled to prevent
+      # conflicting rules. Because it respects user configurations that want to enable
+      # this cop which is disabled by default.
+      #
       # @example
       #   # By default checks every constant
       #

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

@@ -96,8 +96,10 @@ module RuboCop
         end
 
         def debugger_method?(send_node)
+          method_name = send_node.method_name
+
           debugger_methods.any? do |method|
-            next unless method[:method_name] == send_node.method_name
+            next unless method[:method_name] == method_name
 
             if method[:receiver].nil?
               send_node.receiver.nil?

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

@@ -11,6 +11,8 @@ module RuboCop
       #   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.
@@ -21,6 +23,8 @@ module RuboCop
       #   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.
@@ -29,138 +33,84 @@ module RuboCop
       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
+        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
 
-          attr_reader :method, :class_constant
+        DIR_ENV_FILE_CONSTANTS = %i[Dir ENV File].freeze
 
-          def initialize(method, class_constant: nil, correctable: true)
-            @method = method
-            @class_constant = class_constant
-            @correctable = correctable
-          end
-
-          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_DELIMITER
+            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_DELIMITER : CLASS_METHOD_DELIMITER
-          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(:freeze, class_constant: :ENV) =>
-            Replacement.new(nil, class_constant: :ENV),
+        def preferred_method(node)
+          if node.method?(:attr)
+            boolean_argument = node.arguments[1].source
+            preferred_attr_method = boolean_argument == 'true' ? 'attr_accessor' : 'attr_reader'
 
-          DeprecatedClassMethod.new(:clone, class_constant: :ENV) =>
-            Replacement.new(:to_h, class_constant: :ENV),
-
-          DeprecatedClassMethod.new(:dup, class_constant: :ENV) =>
-            Replacement.new(:to_h, class_constant: :ENV),
-
-          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
+            "#{preferred_attr_method} #{node.first_argument.source}"
+          elsif dir_env_file_const?(node.receiver)
+            prefer = PREFERRED_METHDOS[node.method_name]
 
-        RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.keys.map(&:method).freeze
-
-        CLASS_METHOD_DELIMITER = '.'
-        INSTANCE_METHOD_DELIMITER = '#'
-
-        def on_send(node)
-          check(node) do |deprecated|
-            prefer = replacement(deprecated)
-            message = format(MSG, current: deprecated, prefer: prefer)
-            current_method = node.loc.selector
-
-            add_offense(current_method, message: message) do |corrector|
-              next unless deprecated.correctable?
-
-              if (preferred_method = prefer.method)
-                corrector.replace(current_method, preferred_method)
-              else
-                corrector.remove(node.loc.dot)
-                corrector.remove(current_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

@@ -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

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

@@ -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_methods.rb

@@ -57,19 +57,20 @@ module RuboCop
         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?
@@ -157,16 +158,18 @@ module RuboCop
 
         def found_method(node, method_name)
           key = method_key(node, method_name)
+          scope = node.each_ancestor(:rescue, :ensure).first&.type
 
           if @definitions.key?(key)
-            loc = if DEF_TYPES.include?(node.type)
-                    node.loc.keyword.join(node.loc.name)
-                  else
-                    node.loc.expression
-                  end
+            if scope && !@scopes[scope].include?(key)
+              @definitions[key] = node
+              @scopes[scope] << key
+              return
+            end
+
             message = message_for_dup(node, method_name, key)
 
-            add_offense(loc, message: message)
+            add_offense(location(node), message: message)
           else
             @definitions[key] = node
           end
@@ -180,6 +183,14 @@ module RuboCop
           end
         end
 
+        def location(node)
+          if DEF_TYPES.include?(node.type)
+            node.loc.keyword.join(node.loc.name)
+          else
+            node.loc.expression
+          end
+        end
+
         def on_attr(node, attr_name, args)
           case attr_name
           when :attr

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

@@ -41,6 +41,7 @@ module RuboCop
       #     do_that
       #   end
       class ElseLayout < Base
+        include Alignment
         include RangeHelp
         extend AutoCorrector
 
@@ -81,12 +82,7 @@ module RuboCop
           corrector.insert_after(node.loc.else, "\n")
 
           blank_range = range_between(node.loc.else.end_pos, first_else.loc.expression.begin_pos)
-          indentation = indent(node, offset: indentation_width)
-          corrector.replace(blank_range, indentation)
-        end
-
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
+          corrector.replace(blank_range, indentation(node))
         end
       end
     end

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

@@ -65,7 +65,7 @@ module RuboCop
 
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return if node.body
-          return if allow_empty_lambdas? && lambda_or_proc?(node)
+          return if allow_empty_lambdas? && node.lambda_or_proc?
           return if cop_config['AllowComments'] && allow_comment?(node)
 
           add_offense(node)
@@ -88,10 +88,6 @@ module RuboCop
           regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
           Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
         end
-
-        def lambda_or_proc?(node)
-          node.lambda? || node.proc?
-        end
       end
     end
   end

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

@@ -68,7 +68,7 @@ module RuboCop
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
         def on_if(node)
-          return if node.body
+          return if node.body || same_line?(node.loc.begin, node.loc.end)
           return if cop_config['AllowComments'] && contains_comments?(node)
 
           add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|

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

@@ -80,6 +80,7 @@ module RuboCop
           num_of_format_args, num_of_expected_fields = count_matches(node)
 
           return false if num_of_format_args == :unknown
+          return false if num_of_expected_fields.zero? && node.child_nodes.first.dstr_type?
 
           matched_arguments_count?(num_of_expected_fields, num_of_format_args)
         end
@@ -94,8 +95,8 @@ module RuboCop
 
         # @!method called_on_string?(node)
         def_node_matcher :called_on_string?, <<~PATTERN
-          {(send {nil? const_type?} _ (str _) ...)
-           (send (str ...) ...)}
+          {(send {nil? const_type?} _ {str dstr} ...)
+           (send {str dstr} ...)}
         PATTERN
 
         def method_with_format_args?(node)
@@ -143,11 +144,11 @@ module RuboCop
           return false if node.const_receiver? && !node.receiver.loc.name.is?(KERNEL)
           return false unless node.method?(name)
 
-          node.arguments.size > 1 && node.first_argument.str_type?
+          node.arguments.size > 1 && string_type?(node.first_argument)
         end
 
         def expected_fields_count(node)
-          return :unknown unless node.str_type?
+          return :unknown unless string_type?(node)
 
           format_string = RuboCop::Cop::Utils::FormatString.new(node.source)
           return 1 if format_string.named_interpolation?
@@ -172,10 +173,9 @@ module RuboCop
         def percent?(node)
           receiver = node.receiver
 
-          percent = node.method?(:%) &&
-                    (STRING_TYPES.include?(receiver.type) || node.first_argument.array_type?)
+          percent = node.method?(:%) && (string_type?(receiver) || node.first_argument.array_type?)
 
-          return false if percent && STRING_TYPES.include?(receiver.type) && heredoc?(node)
+          return false if percent && string_type?(receiver) && heredoc?(node)
 
           percent
         end
@@ -188,6 +188,10 @@ module RuboCop
           format(MSG, arg_num: num_args_for_format, method: method_name,
                       field_num: num_expected_fields)
         end
+
+        def string_type?(node)
+          STRING_TYPES.include?(node.type)
+        end
       end
     end
   end

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

@@ -8,27 +8,25 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   <<-SQL
+      #     bar
+      #   SQL
+      #   .strip_indent
       #
-      #      <<-SQL
-      #        bar
-      #      SQL
-      #      .strip_indent
-      #
-      #      <<-SQL
-      #        bar
-      #      SQL
-      #      .strip_indent
-      #      .trim
+      #   <<-SQL
+      #     bar
+      #   SQL
+      #   .strip_indent
+      #   .trim
       #
       #   # good
+      #   <<~SQL
+      #     bar
+      #   SQL
       #
-      #      <<~SQL
-      #        bar
-      #      SQL
-      #
-      #      <<~SQL.trim
-      #        bar
-      #      SQL
+      #   <<~SQL.trim
+      #     bar
+      #   SQL
       #
       class HeredocMethodCallPosition < Base
         include RangeHelp

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

@@ -6,9 +6,10 @@ module RuboCop
       # Checks for interpolation in a single quoted string.
       #
       # @safety
-      #   This cop is generally safe, but is marked as unsafe because
-      #   it is possible to actually intentionally have text inside
-      #   `#{...}` in a single quoted string.
+      #   This cop's autocorrection is unsafe because although it always replaces single quotes as
+      #   if it were miswritten double quotes, it is not always the case. For example,
+      #   `'#{foo} bar'` would be replaced by `"#{foo} bar"`, so the replaced code would evaluate
+      #   the expression `foo`.
       #
       # @example
       #

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

@@ -8,6 +8,7 @@ module RuboCop
       # Replace numbered captures with non-capturing groupings or
       # named captures.
       #
+      # @example
       #   # bad
       #   /(?<foo>FOO)(BAR)/
       #

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

@@ -44,7 +44,6 @@ module RuboCop
       class NonAtomicFileOperation < Base
         extend AutoCorrector
         include Alignment
-        include RangeHelp
 
         MSG_REMOVE_FILE_EXIST_CHECK = 'Remove unnecessary existence check ' \
                                       '`%<receiver>s.%<method_name>s`.'
@@ -101,10 +100,11 @@ module RuboCop
         def register_offense(node, exist_node)
           add_offense(node, message: message_change_force_method(node)) unless force_method?(node)
 
-          range = range_between(node.parent.loc.keyword.begin_pos,
-                                exist_node.loc.expression.end_pos)
+          parent = node.parent
+          range = parent.loc.keyword.begin.join(parent.condition.source_range.end)
+
           add_offense(range, message: message_remove_file_exist_check(exist_node)) do |corrector|
-            autocorrect(corrector, node, range) unless node.parent.elsif?
+            autocorrect(corrector, node, range) unless parent.elsif?
           end
         end
 
@@ -120,7 +120,12 @@ module RuboCop
         def autocorrect(corrector, node, range)
           corrector.remove(range)
           autocorrect_replace_method(corrector, node)
-          corrector.remove(node.parent.loc.end) if node.parent.multiline?
+
+          if node.parent.modifier_form?
+            corrector.remove(node.source_range.end.join(node.parent.loc.keyword.begin))
+          else
+            corrector.remove(node.parent.loc.end)
+          end
         end
 
         def autocorrect_replace_method(corrector, node)

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

@@ -68,6 +68,12 @@ module RuboCop
           @valid_ref = regexp_conditions.map { |condition| check_regexp(condition) }.compact.max
         end
 
+        def on_in_pattern(node)
+          regexp_patterns = patterns(node).select(&:regexp_type?)
+
+          @valid_ref = regexp_patterns.map { |pattern| check_regexp(pattern) }.compact.max
+        end
+
         def on_nth_ref(node)
           backref, = *node
           return if @valid_ref.nil? || backref <= @valid_ref
@@ -84,6 +90,19 @@ module RuboCop
 
         private
 
+        def patterns(pattern_node)
+          pattern = pattern_node.node_parts[0]
+
+          case pattern.type
+          when :array_pattern, :match_alt
+            pattern.children
+          when :match_as
+            patterns(pattern)
+          else
+            [pattern]
+          end
+        end
+
         def check_regexp(node)
           return if node.interpolation?
 

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

@@ -40,11 +40,16 @@ module RuboCop
           unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
             return true
           end
+          return true if first_argument_block_type?(node.first_argument)
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
             valid_first_argument?(node.first_argument)
         end
 
+        def first_argument_block_type?(first_arg)
+          first_arg.block_type? || first_arg.numblock_type?
+        end
+
         def valid_first_argument?(first_arg)
           first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg)
         end