rubocop 1.21.0 → 1.22.0

data/lib/rubocop/cop/style/identical_conditional_branches.rb

@@ -7,26 +7,28 @@ module RuboCop
       # each branch of a conditional expression. Such expressions should normally
       # be placed outside the conditional expression - before or after it.
       #
-      # This cop is marked unsafe auto-correction as the order of method invocations
-      # must be guaranteed in the following case:
-      #
-      # [source,ruby]
-      # ----
-      # if method_that_modifies_global_state # 1
-      #   method_that_relies_on_global_state # 2
-      #   foo                                # 3
-      # else
-      #   method_that_relies_on_global_state # 2
-      #   bar                                # 3
-      # end
-      # ----
-      #
-      # In such a case, auto-correction may change the invocation order.
-      #
       # NOTE: The cop is poorly named and some people might think that it actually
       # checks for duplicated conditional branches. The name will probably be changed
       # in a future major RuboCop release.
       #
+      # @safety
+      #   Auto-correction is unsafe because changing the order of method invocations
+      #   may change the behaviour of the code. For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   if method_that_modifies_global_state # 1
+      #     method_that_relies_on_global_state # 2
+      #     foo                                # 3
+      #   else
+      #     method_that_relies_on_global_state # 2
+      #     bar                                # 3
+      #   end
+      #   ----
+      #
+      #   In this example, `method_that_relies_on_global_state` will be moved before
+      #   `method_that_modifies_global_state`, which changes the behaviour of the program.
+      #
       # @example
       #   # bad
       #   if condition

data/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb

@@ -6,8 +6,10 @@ module RuboCop
       # This cop checks for redundant `if` with boolean literal branches.
       # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
       # The conditions to be checked are comparison methods, predicate methods, and double negative.
-      # However, auto-correction is unsafe because there is no guarantee that all predicate methods
-      # will return boolean value. Those methods can be allowed with `AllowedMethods` config.
+      #
+      # @safety
+      #   Auto-correction is unsafe because there is no guarantee that all predicate methods
+      #   will return a boolean value. Those methods can be allowed with `AllowedMethods` config.
       #
       # @example
       #   # bad
@@ -23,6 +25,17 @@ module RuboCop
       #   # good
       #   foo == bar
       #
+      # @example
+      #   # bad
+      #   if foo.do_something?
+      #     true
+      #   else
+      #     false
+      #   end
+      #
+      #   # good (but potentially an unsafe correction)
+      #   foo.do_something?
+      #
       # @example AllowedMethods: ['nonzero?']
       #   # good
       #   num.nonzero? ? true : false

data/lib/rubocop/cop/style/infinite_loop.rb

@@ -5,9 +5,10 @@ module RuboCop
     module Style
       # Use `Kernel#loop` for infinite loops.
       #
-      # This cop is marked as unsafe as the rule does not necessarily
-      # apply if the body might raise a `StopIteration` exception; contrary to
-      # other infinite loops, `Kernel#loop` silently rescues that and returns `nil`.
+      # @safety
+      #   This cop is unsafe as the rule should not necessarily apply if the loop
+      #   body might raise a `StopIteration` exception; contrary to other infinite
+      #   loops, `Kernel#loop` silently rescues that and returns `nil`.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/style/inverse_methods.rb

@@ -5,11 +5,18 @@ module RuboCop
     module Style
       # This cop check for usages of not (`not` or `!`) called on a method
       # when an inverse of that method can be used instead.
+      #
       # Methods that can be inverted by a not (`not` or `!`) should be defined
-      # in `InverseMethods`
+      # in `InverseMethods`.
+      #
       # Methods that are inverted by inverting the return
       # of the block that is passed to the method should be defined in
-      # `InverseBlocks`
+      # `InverseBlocks`.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the method
+      #   and its inverse method are both defined on receiver, and also are
+      #   actually inverse of each other.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/style/line_end_concatenation.rb

@@ -6,6 +6,19 @@ module RuboCop
       # This cop checks for string literal concatenation at
       # the end of a line.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the
+      #   receiver is a string, in which case replacing `<<` with `\`
+      #   would result in a syntax error.
+      #
+      #   For example, this would be a false positive:
+      #   [source,ruby]
+      #   ----
+      #   array << 'foo' <<
+      #            'bar' <<
+      #            'baz'
+      #   ----
+      #
       # @example
       #
       #   # bad

data/lib/rubocop/cop/style/module_function.rb

@@ -6,7 +6,14 @@ module RuboCop
       # This cop checks for use of `extend self` or `module_function` in a
       # module.
       #
-      # Supported styles are: module_function, extend_self, forbidden.
+      # Supported styles are: module_function, extend_self, forbidden. `forbidden`
+      # style prohibits the usage of both styles.
+      #
+      # NOTE: the cop won't be activated when the module contains any private methods.
+      #
+      # @safety
+      #   Autocorrection is unsafe (and is disabled by default) because `extend self`
+      #   and `module_function` do not behave exactly the same.
       #
       # @example EnforcedStyle: module_function (default)
       #   # bad
@@ -21,9 +28,6 @@ module RuboCop
       #     # ...
       #   end
       #
-      # In case there are private methods, the cop won't be activated.
-      # Otherwise, it forces to change the flow of the default code.
-      #
       # @example EnforcedStyle: module_function (default)
       #   # good
       #   module Test
@@ -46,8 +50,6 @@ module RuboCop
       #     # ...
       #   end
       #
-      # The option `forbidden` prohibits the usage of both styles.
-      #
       # @example EnforcedStyle: forbidden
       #   # bad
       #   module Test
@@ -68,9 +70,6 @@ module RuboCop
       #     private
       #     # ...
       #   end
-      #
-      # These offenses are not safe to auto-correct since there are different
-      # implications to each approach.
       class ModuleFunction < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector

data/lib/rubocop/cop/style/mutable_constant.rb

@@ -21,8 +21,17 @@ module RuboCop
       #
       # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
       #
-      # NOTE: From Ruby 3.0, this cop allows explicit freezing of interpolated
-      # string literals when `# frozen-string-literal: true` is used.
+      # NOTE: From Ruby 3.0, interpolated strings are not frozen when
+      # `# frozen-string-literal: true` is used, so this cop enforces explicit
+      # freezing for such strings.
+      #
+      # NOTE: From Ruby 3.0, this cop allows explicit freezing of constants when
+      # the `shareable_constant_value` directive is used.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe since any mutations on objects that
+      #   are made frozen will change from being accepted to raising `FrozenError`,
+      #   and will need to be manually refactored.
       #
       # @example EnforcedStyle: literals (default)
       #   # bad
@@ -71,10 +80,6 @@ module RuboCop
       #   # shareable_constant_value: literal
       #   CONST = [1, 2, 3]
       #
-      # NOTE: This special directive helps to create constants
-      # that hold only immutable objects, or Ractor-shareable
-      # constants. - ruby docs
-      #
       class MutableConstant < Base
         # Handles magic comment shareable_constant_value with O(n ^ 2) complexity
         # n - number of lines in the source
@@ -93,7 +98,7 @@ module RuboCop
           end
 
           # Identifies the most recent magic comment with valid shareable constant values
-          # thats in scope for this node
+          # that's in scope for this node
           def magic_comment_in_scope(node)
             processed_source_till_node(node).reverse_each.find do |line|
               MagicComment.parse(line).valid_shareable_constant_value?

data/lib/rubocop/cop/style/numbered_parameters.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for numbered parameters.
+      #
+      # It can either restrict the use of numbered parameters to
+      # single-lined blocks, or disallow completely numbered parameters.
+      #
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # bad
+      #   collection.each do
+      #     puts _1
+      #   end
+      #
+      #   # good
+      #   collection.each { puts _1 }
+      #
+      # @example EnforcedStyle: disallow
+      #   # bad
+      #   collection.each { puts _1 }
+      #
+      #   # good
+      #   collection.each { |item| puts item }
+      #
+      class NumberedParameters < Base
+        include ConfigurableEnforcedStyle
+        extend TargetRubyVersion
+
+        MSG_DISALLOW = 'Avoid using numbered parameters.'
+        MSG_MULTI_LINE = 'Avoid using numbered parameters for multi-line blocks.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_numblock(node)
+          if style == :disallow
+            add_offense(node, message: MSG_DISALLOW)
+          elsif node.multiline?
+            add_offense(node, message: MSG_MULTI_LINE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/numbered_parameters_limit.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop detects use of an excessive amount of numbered parameters in a
+      # single block. Having too many numbered parameters can make code too
+      # cryptic and hard to read.
+      #
+      # The cop defaults to registering an offense if there is more than 1 numbered
+      # parameter but this maximum can be configured by setting `Max`.
+      #
+      # @example Max: 1 (default)
+      #   # bad
+      #   foo { _1.call(_2, _3, _4) }
+      #
+      #   # good
+      #   foo { do_something(_1) }
+      class NumberedParametersLimit < Base
+        extend TargetRubyVersion
+        extend ExcludeLimit
+
+        DEFAULT_MAX_VALUE = 1
+
+        minimum_target_ruby_version 2.7
+        exclude_limit 'Max'
+
+        MSG = 'Avoid using more than %<max>i numbered %<parameter>s; %<count>i detected.'
+
+        def on_numblock(node)
+          _send_node, param_count, * = *node
+          return if param_count <= max_count
+
+          parameter = max_count > 1 ? 'parameters' : 'parameter'
+          message = format(MSG, max: max_count, parameter: parameter, count: param_count)
+          add_offense(node, message: message) { self.max = param_count }
+        end
+
+        private
+
+        def max_count
+          max = cop_config.fetch('Max', DEFAULT_MAX_VALUE)
+
+          # Ruby does not allow more than 9 numbered parameters
+          [max, 9].min
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/numeric_literals.rb

@@ -58,18 +58,17 @@ module RuboCop
 
           case int
           when /^\d+$/
-            return unless (self.min_digits = int.size + 1)
-
-            register_offense(node)
+            register_offense(node) { self.min_digits = int.size + 1 }
           when /\d{4}/, short_group_regex
-            return unless (self.config_to_allow_offenses = { 'Enabled' => false })
-
-            register_offense(node)
+            register_offense(node) { self.config_to_allow_offenses = { 'Enabled' => false } }
           end
         end
 
-        def register_offense(node)
-          add_offense(node) { |corrector| corrector.replace(node, format_number(node)) }
+        def register_offense(node, &_block)
+          add_offense(node) do |corrector|
+            yield
+            corrector.replace(node, format_number(node))
+          end
         end
 
         def short_group_regex

data/lib/rubocop/cop/style/numeric_predicate.rb

@@ -16,6 +16,11 @@ module RuboCop
       # populated with objects which can be compared with integers, but are
       # not themselves `Integer` polymorphic.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   defines the predicates or can be compared to a number, which may lead
+      #   to a false positive for non-standard classes.
+      #
       # @example EnforcedStyle: predicate (default)
       #   # bad
       #

data/lib/rubocop/cop/style/optional_arguments.rb

@@ -6,6 +6,10 @@ module RuboCop
       # This cop checks for optional arguments to methods
       # that do not come at the end of the argument list.
       #
+      # @safety
+      #   This cop is unsafe because changing a method signature will
+      #   implicitly change behaviour.
+      #
       # @example
       #   # bad
       #   def foo(a = 1, b, c)

data/lib/rubocop/cop/style/optional_boolean_parameter.rb

@@ -7,6 +7,10 @@ module RuboCop
       # boolean arguments when defining methods. `respond_to_missing?` method is allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
+      # @safety
+      #   This cop is unsafe because changing a method signature will
+      #   implicitly change behaviour.
+      #
       # @example
       #   # bad
       #   def some_method(bar = false)
@@ -33,8 +37,8 @@ module RuboCop
       class OptionalBooleanParameter < Base
         include AllowedMethods
 
-        MSG = 'Use keyword arguments when defining method with boolean argument.'
-        BOOLEAN_TYPES = %i[true false].freeze
+        MSG = 'Prefer keyword arguments for arguments with a boolean default value; ' \
+              'use `%<replacement>s` instead of `%<original>s`.'
 
         def on_def(node)
           return if allowed_method?(node.method_name)
@@ -42,11 +46,17 @@ module RuboCop
           node.arguments.each do |arg|
             next unless arg.optarg_type?
 
-            _name, value = *arg
-            add_offense(arg) if BOOLEAN_TYPES.include?(value.type)
+            add_offense(arg, message: format_message(arg)) if arg.default_value.boolean_type?
           end
         end
         alias on_defs on_def
+
+        private
+
+        def format_message(argument)
+          source = argument.source
+          format(MSG, original: source, replacement: source.sub(/\s+=/, ':'))
+        end
       end
     end
   end

data/lib/rubocop/cop/style/preferred_hash_methods.rb

@@ -3,10 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop (by default) checks for uses of methods Hash#has_key? and
-      # Hash#has_value? where it enforces Hash#key? and Hash#value?
-      # It is configurable to enforce the inverse, using `verbose` method
-      # names also.
+      # This cop checks for uses of methods `Hash#has_key?` and
+      # `Hash#has_value?`, and suggests using `Hash#key?` and `Hash#value?` instead.
+      #
+      # It is configurable to enforce the verbose method names, by using the
+      # `EnforcedStyle: verbose` configuration.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement methods.
       #
       # @example EnforcedStyle: short (default)
       #  # bad

data/lib/rubocop/cop/style/redundant_argument.rb

@@ -5,22 +5,29 @@ module RuboCop
     module Style
       # This cop checks for a redundant argument passed to certain methods.
       #
-      # Limitations:
-      #
-      # 1. This cop matches for method names only and hence cannot tell apart
-      #    methods with same name in different classes.
-      # 2. This cop is limited to methods with single parameter.
-      # 3. This cop is unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
-      #    That depends on the nature of the target methods, of course.
+      # NOTE: This cop is limited to methods with single parameter.
       #
       # Method names and their redundant arguments can be configured like this:
       #
+      # [source,yaml]
+      # ----
       # Methods:
       #   join: ''
       #   split: ' '
       #   chomp: "\n"
       #   chomp!: "\n"
       #   foo: 2
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because of the following limitations:
+      #
+      #   1. This cop matches by method names only and hence cannot tell apart
+      #      methods with same name in different classes.
+      #   2. This cop may be unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
+      #      That depends on the nature of the target methods, of course. For example, the default
+      #      argument to join is `$OUTPUT_FIELD_SEPARATOR` (or `$,`) rather than `''`, and if that
+      #      global is changed, `''` is no longer a redundant argument.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/style/redundant_fetch_block.rb

@@ -9,6 +9,10 @@ module RuboCop
       # In such cases `fetch(key, value)` method is faster
       # than `fetch(key) { value }`.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   does not have a different implementation of `fetch`.
+      #
       # @example SafeForConstants: false (default)
       #   # bad
       #   hash.fetch(:key) { 5 }

data/lib/rubocop/cop/style/redundant_file_extension_in_require.rb

@@ -25,6 +25,7 @@ module RuboCop
       #   require_relative '../foo.so'
       #
       class RedundantFileExtensionInRequire < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Redundant `.rb` file extension detected.'
@@ -39,13 +40,21 @@ module RuboCop
           require_call?(node) do |name_node|
             return unless name_node.value.end_with?('.rb')
 
-            add_offense(name_node) do |corrector|
-              correction = name_node.value.delete_suffix('.rb')
+            extension_range = extension_range(name_node)
 
-              corrector.replace(name_node, "'#{correction}'")
+            add_offense(extension_range) do |corrector|
+              corrector.remove(extension_range)
             end
           end
         end
+
+        private
+
+        def extension_range(name_node)
+          end_of_path_string = name_node.source_range.end_pos
+
+          range_between(end_of_path_string - 4, end_of_path_string - 1)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_freeze.rb

@@ -59,7 +59,6 @@ module RuboCop
             (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
             (begin (send !{(str _) array} {:+ :- :* :** :/ :%} {float int}))
             (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
-            (send (const {nil? cbase} :ENV) :[] _)
             (send _ {:count :length :size} ...)
             (block (send _ {:count :length :size} ...) ...)
           }

data/lib/rubocop/cop/style/redundant_self.rb

@@ -100,6 +100,10 @@ module RuboCop
           add_lhs_to_local_variables_scopes(rhs, lhs)
         end
 
+        def on_in_pattern(node)
+          add_match_var_scopes(node)
+        end
+
         def on_send(node)
           return unless node.self_receiver? && regular_method_call?(node)
           return if node.parent&.mlhs_type?
@@ -185,6 +189,12 @@ module RuboCop
             add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
           end
         end
+
+        def add_match_var_scopes(in_pattern_node)
+          in_pattern_node.each_descendant(:match_var) do |match_var_node|
+            @local_variables_scopes[in_pattern_node] << match_var_node.children.first
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_self_assignment.rb

@@ -6,9 +6,10 @@ module RuboCop
       # This cop checks for places where redundant assignments are made for in place
       # modification methods.
       #
-      # This cop is marked as unsafe, because it can produce false positives for
-      # user defined methods having one of the expected names, but not modifying
-      # its receiver in place.
+      # @safety
+      #   This cop is unsafe, because it can produce false positives for
+      #   user defined methods having one of the expected names, but not modifying
+      #   its receiver in place.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/style/redundant_sort.rb

@@ -12,6 +12,33 @@ module RuboCop
       # `Enumerable#max_by` can replace `Enumerable#sort_by` calls
       # after which only the first or last element is used.
       #
+      # @safety
+      #   This cop is unsafe, because `sort...last` and `max` may not return the
+      #   same element in all cases.
+      #
+      #   In an enumerable where there are multiple elements where `a <=> b == 0`,
+      #   or where the transformation done by the `sort_by` block has the
+      #   same result, `sort.last` and `max` (or `sort_by.last` and `max_by`)
+      #   will return different elements. `sort.last` will return the last
+      #   element but `max` will return the first element.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #     class MyString < String; end
+      #     strings = [MyString.new('test'), 'test']
+      #     strings.sort.last.class   #=> String
+      #     strings.max.class         #=> MyString
+      #   ----
+      #
+      #   [source,ruby]
+      #   ----
+      #     words = %w(dog horse mouse)
+      #     words.sort_by { |word| word.length }.last   #=> 'mouse'
+      #     words.max_by { |word| word.length }         #=> 'horse'
+      #   ----
+      #
       # @example
       #   # bad
       #   [2, 1, 3].sort.first
@@ -75,48 +102,39 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          if (sort_node, sorter, accessor = redundant_sort?(node.parent))
-            return if use_size_method_in_block?(sort_node)
-
-            ancestor = node.parent
-          elsif (sort_node, sorter, accessor = redundant_sort?(node.parent&.parent))
-            return if use_size_method_in_block?(sort_node)
-
-            ancestor = node.parent.parent
-          else
-            return
-          end
+          ancestor, sort_node, sorter, accessor =
+            find_redundant_sort(node.parent, node.parent&.parent)
+          return unless ancestor
 
           register_offense(ancestor, sort_node, sorter, accessor)
         end
 
         private
 
-        def use_size_method_in_block?(sort_node)
-          return true if sort_node.send_type? && sort_node.block_node&.body&.method?(:size)
-          return false unless sort_node.block_argument?
+        def find_redundant_sort(*nodes)
+          nodes.each do |node|
+            if (sort_node, sorter, accessor = redundant_sort?(node))
+              return [node, sort_node, sorter, accessor]
+            end
+          end
 
-          sort_node.last_argument.children.first.value == :size
+          nil
         end
 
-        def register_offense(ancestor, sort_node, sorter, accessor)
-          message = message(ancestor, sorter, accessor)
+        def register_offense(node, sort_node, sorter, accessor)
+          message = message(node, sorter, accessor)
 
-          add_offense(offense_range(sort_node, ancestor), message: message) do |corrector|
-            autocorrect(corrector, ancestor, sort_node, sorter, accessor)
-          end
-        end
-
-        def autocorrect(corrector, node, sort_node, sorter, accessor)
-          # Remove accessor, e.g. `first` or `[-1]`.
-          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
+          add_offense(offense_range(sort_node, node), message: message) do |corrector|
+            # Remove accessor, e.g. `first` or `[-1]`.
+            corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
 
-          # Replace "sort" or "sort_by" with the appropriate min/max method.
-          corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+            # Replace "sort" or "sort_by" with the appropriate min/max method.
+            corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+          end
         end
 
-        def offense_range(sort_node, ancestor)
-          range_between(sort_node.loc.selector.begin_pos, ancestor.loc.expression.end_pos)
+        def offense_range(sort_node, node)
+          range_between(sort_node.loc.selector.begin_pos, node.loc.expression.end_pos)
         end
 
         def message(node, sorter, accessor)