rubocop 1.29.1 → 1.46.0

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

@@ -6,7 +6,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop detects instances of rubocop:disable comments that can be
+      # Detects instances of rubocop:disable comments that can be
       # removed without causing any offenses to be reported. It's implemented
       # as a cop in that it inherits from the Cop base class and calls
       # add_offense. The unusual part of its implementation is that it doesn't
@@ -71,16 +71,16 @@ module RuboCop
              processed_source.comment_config.comment_only_line?(directive_comment_range.line) &&
              directive_comment_range.begin_pos == line_comment_range.begin_pos
             # When the previous line is blank, it should be retained
-            range_with_surrounding_space(range: directive_comment_range, side: :right)
+            range_with_surrounding_space(directive_comment_range, side: :right)
           else
             # Eat the entire comment, the preceding space, and the preceding
             # newline if there is one.
             original_begin = directive_comment_range.begin_pos
             range = range_with_surrounding_space(
-              range: directive_comment_range, side: :left, newlines: true
+              directive_comment_range, side: :left, newlines: true
             )
 
-            range_with_surrounding_space(range: range,
+            range_with_surrounding_space(range,
                                          side: :right,
                                          # Special for a comment that
                                          # begins the file: remove
@@ -94,13 +94,13 @@ module RuboCop
           # is NOT being removed?
           if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
             # Eat the comma on the left.
-            range = range_with_surrounding_space(range: range, side: :left)
+            range = range_with_surrounding_space(range, side: :left)
             range = range_with_surrounding_comma(range, :left)
           end
 
           range = range_with_surrounding_comma(range, :right)
           # Eat following spaces up to EOL, but not the newline itself.
-          range_with_surrounding_space(range: range, side: :right, newlines: false)
+          range_with_surrounding_space(range, side: :right, newlines: false)
         end
 
         def each_redundant_disable(&block)
@@ -113,6 +113,7 @@ module RuboCop
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
             next if ignore_offense?(line_range)
+            next if expected_final_disable?(cop, line_range)
 
             comment = processed_source.comment_at_line(line_range.begin)
             redundant = if all_disabled?(comment)
@@ -127,23 +128,35 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
             next if ignore_offense?(range)
-            next unless followed_ranges?(previous_range, range)
-
             # If a cop is disabled in a range that begins on the same line as
             # the end of the previous range, it means that the cop was
             # already disabled by an earlier comment. So it's redundant
             # whether there are offenses or not.
+            next unless followed_ranges?(previous_range, range)
+
             comment = processed_source.comment_at_line(range.begin)
 
+            next unless comment
             # Comments disabling all cops don't count since it's reasonable
             # to disable a few select cops first and then all cops further
             # down in the code.
-            yield comment, cop if comment && !all_disabled?(comment)
+            next if all_disabled?(comment)
+
+            redundant =
+              if department_disabled?(cop, comment)
+                find_redundant_department(cop, range)
+              else
+                cop
+              end
+
+            yield comment, redundant if redundant
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def find_redundant_cop(cop, range)
           cop_offenses = offenses_to_check.select { |offense| offense.cop_name == cop }
@@ -179,11 +192,21 @@ module RuboCop
         end
 
         def ignore_offense?(line_range)
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
           disabled_ranges.any? do |range|
             range.cover?(line_range.min) && range.cover?(line_range.max)
           end
         end
 
+        def expected_final_disable?(cop, line_range)
+          # A cop which is disabled in the config is being re-disabled until end of file
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          cop_class &&
+            !processed_source.registry.enabled?(cop_class, config) &&
+            line_range.max == Float::INFINITY
+        end
+
         def department_disabled?(cop, comment)
           directive = DirectiveComment.new(comment)
           directive.in_directive_department?(cop) && !directive.overridden_by_department?(cop)
@@ -209,7 +232,12 @@ module RuboCop
 
           add_offense(location, message: message(cop_names)) do |corrector|
             range = comment_range_with_surrounding_space(location, comment.loc.expression)
-            corrector.remove(range)
+
+            if leave_free_comment?(comment, range)
+              corrector.replace(range, ' # ')
+            else
+              corrector.remove(range)
+            end
           end
         end
 
@@ -227,6 +255,12 @@ module RuboCop
           end
         end
 
+        def leave_free_comment?(comment, range)
+          free_comment = comment.text.gsub(range.source.strip, '')
+
+          !free_comment.empty? && !free_comment.start_with?('#')
+        end
+
         def cop_range(comment, cop)
           cop = remove_department_marker(cop)
           matching_range(comment.loc.expression, cop) ||
@@ -250,12 +284,18 @@ module RuboCop
             .all? { |intervening| /\A\s*,\s*\Z/.match?(intervening) }
         end
 
+        SIMILAR_COP_NAMES_CACHE = Hash.new do |hash, cop_name|
+          hash[:all_cop_names] = Registry.global.names unless hash.key?(:all_cop_names)
+          hash[cop_name] = NameSimilarity.find_similar_name(cop_name, hash[:all_cop_names])
+        end
+        private_constant :SIMILAR_COP_NAMES_CACHE
+
         def describe(cop)
           return 'all cops' if cop == 'all'
           return "`#{remove_department_marker(cop)}` department" if department_marker?(cop)
           return "`#{cop}`" if all_cop_names.include?(cop)
 
-          similar = NameSimilarity.find_similar_name(cop, all_cop_names)
+          similar = SIMILAR_COP_NAMES_CACHE[cop]
           similar ? "`#{cop}` (did you mean `#{similar}`?)" : "`#{cop}` (unknown cop)"
         end
 

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

@@ -9,7 +9,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop detects instances of rubocop:enable comments that can be
+      # Detects instances of rubocop:enable comments that can be
       # removed.
       #
       # When comment enables all cops at once `rubocop:enable all`
@@ -42,7 +42,7 @@ module RuboCop
         MSG = 'Unnecessary enabling of %<cop>s.'
 
         def on_new_investigation
-          return if processed_source.blank?
+          return if processed_source.blank? || !processed_source.raw_source.include?('enable')
 
           offenses = processed_source.comment_config.extra_enabled_comments
           offenses.each { |comment, cop_names| register_offense(comment, cop_names) }
@@ -60,7 +60,7 @@ module RuboCop
               message: format(MSG, cop: all_or_name(name))
             ) do |corrector|
               if directive.match?(cop_names)
-                corrector.remove(range_with_surrounding_space(range: directive.range, side: :right))
+                corrector.remove(range_with_surrounding_space(directive.range, side: :right))
               else
                 corrector.remove(range_with_comma(comment, name))
               end

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

@@ -41,6 +41,7 @@ module RuboCop
           return unless (receiver = node.receiver)
           return unless receiver.receiver&.const_type? && receiver.receiver.short_name == :Dir
           return unless GLOB_METHODS.include?(receiver.method_name)
+          return if multiple_argument?(receiver)
 
           selector = node.loc.selector
 
@@ -49,6 +50,12 @@ module RuboCop
             corrector.remove(node.loc.dot)
           end
         end
+
+        private
+
+        def multiple_argument?(glob_method)
+          glob_method.arguments.count >= 2 || glob_method.first_argument&.splat_type?
+        end
       end
     end
   end

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

@@ -6,13 +6,23 @@ module RuboCop
       # Checks for unnecessary `require` statement.
       #
       # The following features are unnecessary `require` statement because
-      # they are already loaded.
+      # they are already loaded. e.g. Ruby 2.2:
       #
       #   ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }'
       #   ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]
       #   ["enumerator.so", "rational.so", "complex.so", "thread.rb"]
       #
-      # This cop targets Ruby 2.2 or higher containing these 4 features.
+      # Below are the features that each `TargetRubyVersion` targets.
+      #
+      #   * 2.0+ ... `enumerator`
+      #   * 2.1+ ... `thread`
+      #   * 2.2+ ... Add `rational` and `complex` above
+      #   * 2.5+ ... Add `pp` above
+      #   * 2.7+ ... Add `ruby2_keywords` above
+      #   * 3.1+ ... Add `fiber` above
+      #   * 3.2+ ... `set`
+      #
+      # This cop target those features.
       #
       # @example
       #   # bad
@@ -27,22 +37,53 @@ 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 unnecessary_require_statement?(node)
-        def_node_matcher :unnecessary_require_statement?, <<~PATTERN
+        # @!method redundant_require_statement?(node)
+        def_node_matcher :redundant_require_statement?, <<~PATTERN
           (send nil? :require
-            (str {"enumerator" "rational" "complex" "thread"}))
+            (str #redundant_feature?))
         PATTERN
 
         def on_send(node)
-          return unless unnecessary_require_statement?(node)
+          return unless redundant_require_statement?(node)
 
           add_offense(node) do |corrector|
-            range = range_with_surrounding_space(range: node.loc.expression, side: :right)
+            if node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+              corrector.insert_after(node.parent, "\nend")
+
+              range = range_with_surrounding_space(node.loc.expression, side: :right)
+            else
+              range = range_by_whole_lines(node.source_range, include_final_newline: true)
+            end
 
             corrector.remove(range)
           end
         end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def redundant_feature?(feature_name)
+          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' && !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/redundant_safe_navigation.rb

@@ -3,17 +3,22 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for redundant safe navigation calls.
+      # Checks for redundant safe navigation calls.
       # `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods
       # are checked by default. These are customizable with `AllowedMethods` option.
       #
+      # The `AllowedMethods` option specifies nil-safe methods,
+      # in other words, it is a method that is allowed to skip safe navigation.
+      # Note that the `AllowedMethod` option is not an option that specifies methods
+      # for which to suppress (allow) this cop's check.
+      #
       # In the example below, the safe navigation operator (`&.`) is unnecessary
       # because `NilClass` has methods like `respond_to?` and `is_a?`.
       #
       # @safety
-      #   This cop is unsafe, because auto-correction can change the return type of
+      #   This cop is unsafe, because autocorrection can change the return type of
       #   the expression. An offending expression that previously could return `nil`
-      #   will be auto-corrected to never return `nil`.
+      #   will be autocorrected to never return `nil`.
       #
       # @example
       #   # bad
@@ -35,6 +40,14 @@ module RuboCop
       #   # good - without `&.` this will always return `true`
       #   foo&.respond_to?(:to_a)
       #
+      # @example AllowedMethods: [nil_safe_method]
+      #   # bad
+      #   do_something if attrs&.nil_safe_method(:[])
+      #
+      #   # good
+      #   do_something if attrs.nil_safe_method(:[])
+      #   do_something if attrs&.not_nil_safe_method(:[])
+      #
       class RedundantSafeNavigation < Base
         include AllowedMethods
         include RangeHelp

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for unneeded usages of splat expansion
+      # Checks for unneeded usages of splat expansion
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for string conversion in string interpolation,
+      # Checks for string conversion in string interpolation,
       # which is redundant.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for redundant `with_index`.
+      # Checks for redundant `with_index`.
       #
       # @example
       #   # bad
@@ -33,16 +33,6 @@ module RuboCop
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
-        # @!method redundant_with_index?(node)
-        def_node_matcher :redundant_with_index?, <<~PATTERN
-          (block
-            $(send
-              _ {:each_with_index :with_index} ...)
-            (args
-              (arg _))
-            ...)
-        PATTERN
-
         def on_block(node)
           return unless (send = redundant_with_index?(node))
 
@@ -58,8 +48,21 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
+        # @!method redundant_with_index?(node)
+        def_node_matcher :redundant_with_index?, <<~PATTERN
+          {
+            (block
+              $(send _ {:each_with_index :with_index} ...)
+              (args (arg _)) ...)
+            (numblock
+              $(send _ {:each_with_index :with_index} ...) 1 ...)
+          }
+        PATTERN
+
         def message(node)
           if node.method?(:each_with_index)
             MSG_EACH_WITH_INDEX

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for redundant `with_object`.
+      # Checks for redundant `with_object`.
       #
       # @example
       #   # bad
@@ -31,19 +31,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG_EACH_WITH_OBJECT = 'Use `each` instead of `each_with_object`.'
-
         MSG_WITH_OBJECT = 'Remove redundant `with_object`.'
 
-        # @!method redundant_with_object?(node)
-        def_node_matcher :redundant_with_object?, <<~PATTERN
-          (block
-            $(send _ {:each_with_object :with_object}
-              _)
-            (args
-              (arg _))
-            ...)
-        PATTERN
-
         def on_block(node)
           return unless (send = redundant_with_object?(node))
 
@@ -59,8 +48,20 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
+        # @!method redundant_with_object?(node)
+        def_node_matcher :redundant_with_object?, <<~PATTERN
+          {
+            (block
+              $(send _ {:each_with_object :with_object} _) (args (arg _)) ...)
+            (numblock
+              $(send _ {:each_with_object :with_object} _) 1 ...)
+          }
+        PATTERN
+
         def message(node)
           if node.method?(:each_with_object)
             MSG_EACH_WITH_OBJECT

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks if `include` or `prepend` is called in `refine` block.
+      # Checks if `include` or `prepend` is called in `refine` block.
       # These methods are deprecated and should be replaced with `Refinement#import_methods`.
       #
       # It emulates deprecation warnings in Ruby 3.1.
@@ -41,7 +41,8 @@ module RuboCop
 
         def on_send(node)
           return if node.receiver
-          return unless node.parent.block_type? && node.parent.method?(:refine)
+          return unless (parent = node.parent)
+          return unless parent.block_type? && parent.method?(:refine)
 
           add_offense(node.loc.selector, message: format(MSG, current: node.method_name))
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for regexp literals used as `match-current-line`.
+      # Checks for regexp literals used as `match-current-line`.
       # If a regexp literal is in condition, the regexp matches `$_` implicitly.
       #
       # @example
@@ -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.'
+        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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for expressions where there is a call to a predicate
+      # Checks for expressions where there is a call to a predicate
       # method with at least one argument, where no parentheses are used around
       # the parameter list, and a boolean operator, && or ||, is used in the
       # last argument.
@@ -46,7 +46,9 @@ module RuboCop
         private
 
         def check_ternary(ternary, node)
-          return unless 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/require_range_parentheses.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that a range literal is enclosed in parentheses when the end of the range is
+      # at a line break.
+      #
+      # NOTE: The following is maybe intended for `(42..)`. But, compatible is `42..do_something`.
+      # So, this cop does not provide autocorrection because it is left to user.
+      #
+      # [source,ruby]
+      # ----
+      # case condition
+      # when 42..
+      #   do_something
+      # end
+      # ----
+      #
+      # @example
+      #
+      #   # bad - Represents `(1..42)`, not endless range.
+      #   1..
+      #   42
+      #
+      #   # good - It's incompatible, but your intentions when using endless range may be:
+      #   (1..)
+      #   42
+      #
+      #   # good
+      #   1..42
+      #
+      #   # good
+      #   (1..42)
+      #
+      #   # good
+      #   (1..
+      #   42)
+      #
+      class RequireRangeParentheses < Base
+        MSG = 'Wrap the endless range literal `%<range>s` to avoid precedence ambiguity.'
+
+        def on_irange(node)
+          return if node.parent&.begin_type?
+          return unless node.begin && node.end
+          return if same_line?(node.begin, node.end)
+
+          message = format(MSG, range: "#{node.begin.source}#{node.loc.operator.source}")
+
+          add_offense(node, message: message)
+        end
+
+        alias on_erange on_irange
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for `rescue` blocks targeting the Exception class.
+      # Checks for `rescue` blocks targeting the Exception class.
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for the use of a return with a value in a context
+      # Checks for the use of a return with a value in a context
       # where the value will be ignored. (initialize and setter methods)
       #
       # @example

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

@@ -25,8 +25,13 @@ module RuboCop
       #   x&.foo || bar
       class SafeNavigationChain < Base
         include NilMethods
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
 
         MSG = 'Do not chain ordinary method call after safe navigation operator.'
+        PLUS_MINUS_METHODS = %i[+@ -@].freeze
 
         # @!method bad_method?(node)
         def_node_matcher :bad_method?, <<~PATTERN
@@ -38,23 +43,54 @@ module RuboCop
 
         def on_send(node)
           bad_method?(node) do |safe_nav, method|
-            return if nil_methods.include?(method)
+            return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
 
-            method_chain = method_chain(node)
             location =
               Parser::Source::Range.new(node.source_range.source_buffer,
                                         safe_nav.source_range.end_pos,
-                                        method_chain.source_range.end_pos)
-            add_offense(location)
+                                        node.source_range.end_pos)
+            add_offense(location) do |corrector|
+              autocorrect(corrector, offense_range: location, send_node: node)
+            end
           end
         end
 
         private
 
-        def method_chain(node)
-          chain = node
-          chain = chain.parent if chain.send_type? && chain.parent&.call_type?
-          chain
+        # @param [Parser::Source::Range] offense_range
+        # @param [RuboCop::AST::SendNode] send_node
+        # @return [String]
+        def add_safe_navigation_operator(offense_range:, send_node:)
+          source =
+            if brackets?(send_node)
+              format(
+                '%<method_name>s(%<arguments>s)%<method_chain>s',
+                arguments: send_node.arguments.map(&:source).join(', '),
+                method_name: send_node.method_name,
+                method_chain: send_node.source_range.end.join(send_node.source_range.end).source
+              )
+            else
+              offense_range.source
+            end
+          source.prepend('.') unless source.start_with?('.')
+          source.prepend('&')
+        end
+
+        # @param [RuboCop::Cop::Corrector] corrector
+        # @param [Parser::Source::Range] offense_range
+        # @param [RuboCop::AST::SendNode] send_node
+        def autocorrect(corrector, offense_range:, send_node:)
+          corrector.replace(
+            offense_range,
+            add_safe_navigation_operator(
+              offense_range: offense_range,
+              send_node: send_node
+            )
+          )
+        end
+
+        def brackets?(send_node)
+          send_node.method?(:[]) || send_node.method?(:[]=)
         end
       end
     end