rubocop 1.41.1 → 1.45.1

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/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/format_parameter_mismatch.rb

@@ -81,6 +81,10 @@ module RuboCop
 
           return false if num_of_format_args == :unknown
 
+          first_arg = node.first_argument
+          return false if num_of_expected_fields.zero? &&
+                          (first_arg.dstr_type? || first_arg.array_type?)
+
           matched_arguments_count?(num_of_expected_fields, num_of_format_args)
         end
 
@@ -94,8 +98,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 +147,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 +176,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 +191,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/implicit_string_concatenation.rb

@@ -81,7 +81,7 @@ module RuboCop
         end
 
         def display_str(node)
-          if /\n/.match?(node.source)
+          if node.source.include?("\n")
             str_content(node).inspect
           else
             node.source

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/nested_method_definition.rb

@@ -108,7 +108,7 @@ module RuboCop
           return unless def_ancestor
 
           within_scoping_def =
-            node.each_ancestor(:block, :sclass).any? do |ancestor|
+            node.each_ancestor(:block, :numblock, :sclass).any? do |ancestor|
               scoping_method_call?(ancestor)
             end
 
@@ -120,7 +120,7 @@ module RuboCop
 
         def scoping_method_call?(child)
           child.sclass_type? || eval_call?(child) || exec_call?(child) ||
-            class_or_module_or_struct_new_call?(child) || allowed_method_name?(child)
+            class_constructor?(child) || allowed_method_name?(child)
         end
 
         def allowed_method_name?(node)
@@ -139,9 +139,12 @@ module RuboCop
           (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
 
-        # @!method class_or_module_or_struct_new_call?(node)
-        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
+        # @!method class_constructor?(node)
+        def_node_matcher :class_constructor?, <<~PATTERN
+          ({block numblock} {
+            (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+            (send (const {nil? cbase} :Data) :define ...)
+          } ...)
         PATTERN
       end
     end

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/redundant_require_statement.rb

@@ -38,6 +38,10 @@ module RuboCop
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
         RUBY_22_LOADED_FEATURES = %w[rational complex].freeze
+        PRETTY_PRINT_METHODS = %i[
+          pretty_inspect pretty_print pretty_print_cycle
+          pretty_print_inspect pretty_print_instance_variables
+        ].freeze
 
         # @!method redundant_require_statement?(node)
         def_node_matcher :redundant_require_statement?, <<~PATTERN
@@ -68,12 +72,18 @@ module RuboCop
           feature_name == 'enumerator' ||
             (target_ruby_version >= 2.1 && feature_name == 'thread') ||
             (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
-            (target_ruby_version >= 2.5 && feature_name == 'pp') ||
+            (target_ruby_version >= 2.5 && feature_name == 'pp' && !use_pretty_print_method?) ||
             (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
             (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
             (target_ruby_version >= 3.2 && feature_name == 'set')
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def use_pretty_print_method?
+          processed_source.ast.each_descendant(:send).any? do |node|
+            PRETTY_PRINT_METHODS.include?(node.method_name)
+          end
+        end
       end
     end
   end

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

@@ -17,13 +17,19 @@ module RuboCop
       #     do_something
       #   end
       class RegexpAsCondition < Base
+        include IgnoredNode
         extend AutoCorrector
 
         MSG = 'Do not use regexp literal as a condition. ' \
               'The regexp literal matches `$_` implicitly.'
 
         def on_match_current_line(node)
+          return if node.ancestors.none?(&:conditional?)
+          return if part_of_ignored_node?(node)
+
           add_offense(node) { |corrector| corrector.replace(node, "#{node.source} =~ $_") }
+
+          ignore_node(node)
         end
       end
     end

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

@@ -46,7 +46,9 @@ module RuboCop
         private
 
         def check_ternary(ternary, node)
-          return if node.method?(:[]) || !ternary.condition.operator_keyword?
+          if node.method?(:[]) || node.assignment_method? || !ternary.condition.operator_keyword?
+            return
+          end
 
           range = range_between(node.source_range.begin_pos, ternary.condition.source_range.end_pos)
 

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

@@ -100,7 +100,8 @@ module RuboCop
 
           unless variable.keyword_argument?
             message << " If it's necessary, use `_` or `_#{variable.name}` " \
-                       "as an argument name to indicate that it won't be used."
+                       "as an argument name to indicate that it won't be used. " \
+                       "If it's unnecessary, remove it."
           end
 
           scope = variable.scope

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

@@ -167,9 +167,12 @@ module RuboCop
           ({block numblock} (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
-        # @!method class_or_module_or_struct_new_call?(node)
-        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          ({block numblock} (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
+        # @!method class_constructor?(node)
+        def_node_matcher :class_constructor?, <<~PATTERN
+          ({block numblock} {
+            (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+            (send (const {nil? cbase} :Data) :define ...)
+          } ...)
         PATTERN
 
         def check_node(node)
@@ -270,7 +273,7 @@ module RuboCop
 
         def eval_call?(child)
           class_or_instance_eval?(child) ||
-            class_or_module_or_struct_new_call?(child) ||
+            class_constructor?(child) ||
             any_context_creating_methods?(child)
         end
 

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

@@ -41,7 +41,7 @@ module RuboCop
         MSG = 'Useless method definition detected.'
 
         def on_def(node)
-          return if optional_args?(node)
+          return if use_rest_or_optional_args?(node)
           return unless delegating?(node.body, node)
 
           add_offense(node) { |corrector| corrector.remove(node) }
@@ -50,8 +50,8 @@ module RuboCop
 
         private
 
-        def optional_args?(node)
-          node.arguments.any? { |arg| arg.optarg_type? || arg.kwoptarg_type? }
+        def use_rest_or_optional_args?(node)
+          node.arguments.any? { |arg| arg.restarg_type? || arg.optarg_type? || arg.kwoptarg_type? }
         end
 
         def delegating?(node, def_node)

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless `rescue`s, which only reraise rescued exceptions.
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     do_something
+      #   rescue
+      #     raise
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     do_something
+      #   rescue => e
+      #     raise # or 'raise e', or 'raise $!', or 'raise $ERROR_INFO'
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     do_something
+      #   rescue
+      #     do_cleanup
+      #     raise
+      #   end
+      #
+      #   # bad (latest rescue)
+      #   def foo
+      #     do_something
+      #   rescue ArgumentError
+      #     # noop
+      #   rescue
+      #     raise
+      #   end
+      #
+      #   # good (not the latest rescue)
+      #   def foo
+      #     do_something
+      #   rescue ArgumentError
+      #     raise
+      #   rescue
+      #     # noop
+      #   end
+      #
+      class UselessRescue < Base
+        MSG = 'Useless `rescue` detected.'
+
+        def on_rescue(node)
+          resbody_node = node.resbody_branches.last
+          add_offense(resbody_node) if only_reraising?(resbody_node)
+        end
+
+        private
+
+        def only_reraising?(resbody_node)
+          return false if use_exception_variable_in_ensure?(resbody_node)
+
+          body = resbody_node.body
+          return false if body.nil? || !body.send_type? || !body.method?(:raise)
+          return true unless body.arguments?
+          return false if body.arguments.size > 1
+
+          exception_name = body.first_argument.source
+
+          exception_objects(resbody_node).include?(exception_name)
+        end
+
+        def use_exception_variable_in_ensure?(resbody_node)
+          return false unless (exception_variable = resbody_node.exception_variable)
+          return false unless (ensure_node = resbody_node.each_ancestor(:ensure).first)
+
+          ensure_node.body.each_descendant(:lvar).map(&:source).include?(exception_variable.source)
+        end
+
+        def exception_objects(resbody_node)
+          [resbody_node.exception_variable&.source, '$!', '$ERROR_INFO']
+        end
+      end
+    end
+  end
+end

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

@@ -77,10 +77,12 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          if node.first_argument.def_type?
-            inspect_def(node, node.first_argument)
+          return unless (first_argument = node.first_argument)
+
+          if first_argument.def_type?
+            inspect_def(node, first_argument)
           elsif node.first_argument.sym_type?
-            inspect_sym(node, node.first_argument)
+            inspect_sym(node, first_argument)
           end
         end
 
@@ -96,7 +98,7 @@ module RuboCop
           return unless node.parent
 
           method_name = sym_node.value
-          definition = node.parent.each_child_node.detect { |n| method_definition(n, method_name) }
+          definition = find_method_definition(node, method_name)
 
           return unless definition
           return if allowed_arguments(definition.arguments)
@@ -104,6 +106,14 @@ module RuboCop
           add_offense(node, message: format(MSG, method_name: method_name))
         end
 
+        def find_method_definition(node, method_name)
+          node.each_ancestor.lazy.map do |ancestor|
+            ancestor.each_child_node(:def, :block, :numblock).find do |child|
+              method_definition(child, method_name)
+            end
+          end.find(&:itself)
+        end
+
         # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
         def allowed_arguments(arguments)
           return false if arguments.empty?