rubocop 1.20.0 → 1.22.2

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

@@ -67,17 +67,27 @@ module RuboCop
             # so this can cause crashes in haml_lint
             return unless def_node
 
+            block_name = extract_block_name(def_node)
+
             add_offense(block_node) do |corrector|
               corrector.remove(block_body_range(block_node, send_node))
 
-              add_block_argument(send_node, corrector)
-              add_block_argument(def_node, corrector) if @def_nodes.add?(def_node)
+              add_block_argument(send_node, corrector, block_name)
+              add_block_argument(def_node, corrector, block_name) if @def_nodes.add?(def_node)
             end
           end
         end
 
         private
 
+        def extract_block_name(def_node)
+          if def_node.block_argument?
+            def_node.arguments.last.name
+          else
+            'block'
+          end
+        end
+
         def yielding_arguments?(block_args, yield_args)
           yield_args = yield_args.dup.fill(
             nil,
@@ -91,15 +101,15 @@ module RuboCop
           end
         end
 
-        def add_block_argument(node, corrector)
+        def add_block_argument(node, corrector, block_name)
           if node.arguments?
-            insert_argument(node, corrector)
+            insert_argument(node, corrector, block_name)
           elsif empty_arguments?(node)
-            corrector.replace(node.arguments, '(&block)')
+            corrector.replace(node.arguments, "(&#{block_name})")
           elsif call_like?(node)
-            correct_call_node(node, corrector)
+            correct_call_node(node, corrector, block_name)
           else
-            corrector.insert_after(node.loc.name, '(&block)')
+            corrector.insert_after(node.loc.name, "(&#{block_name})")
           end
         end
 
@@ -112,16 +122,16 @@ module RuboCop
           node.call_type? || node.zsuper_type? || node.super_type?
         end
 
-        def insert_argument(node, corrector)
+        def insert_argument(node, corrector, block_name)
           last_arg = node.arguments.last
           arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
-          replacement = ' &block'
+          replacement = " &#{block_name}"
           replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
           corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
         end
 
-        def correct_call_node(node, corrector)
-          corrector.insert_after(node, '(&block)')
+        def correct_call_node(node, corrector, block_name)
+          corrector.insert_after(node, "(&#{block_name})")
           return unless node.parenthesized?
 
           args_begin = Util.args_begin(node)

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

@@ -7,8 +7,16 @@ module RuboCop
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #
-      # This cop is marked as unsafe, because if operand variable is a string object
-      # then `.to_f` will be removed and an error will occur.
+      # @safety
+      #   This cop is unsafe, because if the operand variable is a string object
+      #   then `.to_f` will be removed and an error will occur.
+      #
+      #   [source,ruby]
+      #   ----
+      #   a = '1.2'
+      #   b = '3.4'
+      #   a.to_f / b.to_f # Both `to_f` calls are required here
+      #   ----
       #
       # @example EnforcedStyle: single_coerce (default)
       #   # bad

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

@@ -10,12 +10,17 @@ module RuboCop
       # default in future Ruby. The comment will be added below a shebang and
       # encoding comment.
       #
-      # Note that the cop will ignore files where the comment exists but is set
+      # Note that the cop will accept files where the comment exists but is set
       # to `false` instead of `true`.
       #
       # To require a blank line after this comment, please see
       # `Layout/EmptyLineAfterMagicComment` cop.
       #
+      # @safety
+      #  This cop's autocorrection is unsafe since any strings mutations will
+      #  change from being accepted to raising `FrozenError`, as all strings
+      #  will become frozen by default, and will need to be manually refactored.
+      #
       # @example EnforcedStyle: always (default)
       #   # The `always` style will always add the frozen string literal comment
       #   # to a file, regardless of the Ruby version or if `freeze` or `<<` are

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

@@ -8,6 +8,10 @@ module RuboCop
       # reassign (possibly to redirect some stream) constants in Ruby, you'll get
       # an interpreter warning if you do so.
       #
+      # @safety
+      #   Autocorrection is unsafe because `STDOUT` and `$stdout` may point to different
+      #   objects, for example.
+      #
       # @example
       #   # bad
       #   STDOUT.puts('hello')

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

@@ -9,6 +9,11 @@ module RuboCop
       #   parentheses around the block arguments to indicate that you're not
       #   working with a hash, and suppress RuboCop offenses.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash`. The `AllowedReceivers` configuration can mitigate,
+      #   but not fully resolve, this safety issue.
+      #
       # @example
       #   # bad
       #   hash.keys.each { |k| p k }

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

@@ -8,12 +8,10 @@ module RuboCop
       # transforming the keys of a hash, and tries to use a simpler & faster
       # call to `transform_keys` instead.
       #
-      # This can produce false positives if we are transforming an enumerable
-      # of key-value-like pairs that isn't actually a hash, e.g.:
-      # `[[k1, v1], [k2, v2], ...]`
-      #
-      # This cop should only be enabled on Ruby version 2.5 or newer
-      # (`transform_keys` was added in Ruby 2.5.)
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if we are
+      #   transforming an enumerable of key-value-like pairs that isn't actually
+      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
       #
       # @example
       #   # bad

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

@@ -8,12 +8,10 @@ module RuboCop
       # transforming the values of a hash, and tries to use a simpler & faster
       # call to `transform_values` instead.
       #
-      # This can produce false positives if we are transforming an enumerable
-      # of key-value-like pairs that isn't actually a hash, e.g.:
-      # `[[k1, v1], [k2, v2], ...]`
-      #
-      # This cop should only be enabled on Ruby version 2.4 or newer
-      # (`transform_values` was added in Ruby 2.4.)
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if we are
+      #   transforming an enumerable of key-value-like pairs that isn't actually
+      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
       #
       # @example
       #   # bad

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
@@ -109,12 +122,13 @@ module RuboCop
         end
 
         def opposite_condition?(node)
-          !node.unless? && node.if_branch.false_type? || node.unless? && node.if_branch.true_type?
+          (!node.unless? && node.if_branch.false_type?) ||
+            (node.unless? && node.if_branch.true_type?)
         end
 
         def require_parentheses?(condition)
           condition.and_type? || condition.or_type? ||
-            condition.send_type? && condition.comparison_method?
+            (condition.send_type? && condition.comparison_method?)
         end
       end
     end

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

@@ -52,7 +52,7 @@ module RuboCop
         private
 
         def offense?(node)
-          explicit_style? && node.implicit_call? || implicit_style? && !node.implicit_call?
+          (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end
 
         def message(_node)

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
@@ -46,7 +59,7 @@ module RuboCop
 
           return unless eligible_token_set?(predecessor, operator, successor)
 
-          return if operator.line == successor.line
+          return if same_line?(operator, successor)
 
           next_successor = token_after_last_string(successor, index)
 

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -93,8 +93,8 @@ module RuboCop
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
             parent &&
               (logical_operator?(parent) ||
-              parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) })
+              (parent.send_type? &&
+              parent.arguments.any? { |argument| logical_operator?(argument) }))
           end
 
           def call_in_optional_arguments?(node)
@@ -122,14 +122,14 @@ module RuboCop
 
           def call_as_argument_or_chain?(node)
             node.parent &&
-              (node.parent.send_type? && !assigned_before?(node.parent, node) ||
+              ((node.parent.send_type? && !assigned_before?(node.parent, node)) ||
               node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
           end
 
           def hash_literal_in_arguments?(node)
             node.arguments.any? do |n|
               hash_literal?(n) ||
-                n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) }
+                (n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) })
             end
           end
 
@@ -171,8 +171,8 @@ module RuboCop
           end
 
           def unary_literal?(node)
-            node.numeric_type? && node.sign? ||
-              node.parent&.send_type? && node.parent&.unary_operation?
+            (node.numeric_type? && node.sign?) ||
+              (node.parent&.send_type? && node.parent&.unary_operation?)
           end
 
           def assigned_before?(node, target)

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

@@ -54,7 +54,7 @@ module RuboCop
           return true if in_pattern_node.pattern.first_line != in_pattern_node.pattern.last_line
           return false unless in_pattern_node.body
 
-          in_pattern_node.loc.line == in_pattern_node.body.loc.line
+          same_line?(in_pattern_node, in_pattern_node.body)
         end
       end
     end

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

@@ -54,7 +54,7 @@ module RuboCop
           end
           return false unless when_node.body
 
-          when_node.loc.line == when_node.body.loc.line
+          same_line?(when_node, when_node.body)
         end
 
         def accept_node_type?(node)

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?
@@ -153,7 +158,7 @@ module RuboCop
         def check(value)
           range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
           return unless mutable_literal?(value) ||
-                        target_ruby_version <= 2.7 && range_enclosed_in_parentheses
+                        (target_ruby_version <= 2.7 && range_enclosed_in_parentheses)
 
           return if frozen_string_literal?(value)
           return if shareable_constant_value?(value)

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

@@ -90,7 +90,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :prefix && node.modifier_form? || style == :postfix && !node.modifier_form?
+          (style == :prefix && node.modifier_form?) || (style == :postfix && !node.modifier_form?)
         end
       end
     end

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

@@ -80,7 +80,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :prefix && node.modifier_form? || style == :postfix && !node.modifier_form?
+          (style == :prefix && node.modifier_form?) || (style == :postfix && !node.modifier_form?)
         end
       end
     end

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

@@ -63,7 +63,7 @@ module RuboCop
 
         def on_send(node)
           return if ignored_node?(node) ||
-                    !include_semantic_changes? && nil_comparison_style == 'comparison'
+                    (!include_semantic_changes? && nil_comparison_style == 'comparison')
           return unless register_offense?(node)
 
           message = message(node)
@@ -87,7 +87,7 @@ module RuboCop
 
         def register_offense?(node)
           not_equal_to_nil?(node) ||
-            include_semantic_changes? && (not_and_nil_check?(node) || unless_and_nil_check?(node))
+            (include_semantic_changes? && (not_and_nil_check?(node) || unless_and_nil_check?(node)))
         end
 
         def autocorrect(corrector, node)

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

@@ -53,8 +53,8 @@ module RuboCop
 
         def requires_parens?(child)
           child.and_type? || child.or_type? ||
-            child.send_type? && child.binary_operation? ||
-            child.if_type? && child.ternary?
+            (child.send_type? && child.binary_operation?) ||
+            (child.if_type? && child.ternary?)
         end
 
         def correct_opposite_method(corrector, range, child)

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