rubocop 1.21.0 → 1.22.0

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

@@ -10,14 +10,25 @@ module RuboCop
       # need to be changed to use safe navigation. We have limited the cop to
       # not register an offense for method chains that exceed 2 methods.
       #
-      # Configuration option: ConvertCodeThatCanStartToReturnNil
-      # The default for this is `false`. When configured to `true`, this will
+      # The default for `ConvertCodeThatCanStartToReturnNil` is `false`.
+      # When configured to `true`, this will
       # check for code in the format `!foo.nil? && foo.bar`. As it is written,
       # the return of this code is limited to `false` and whatever the return
       # of the method is. If this is converted to safe navigation,
       # `foo&.bar` can start returning `nil` as well as what the method
       # returns.
       #
+      # @safety
+      #   Autocorrection is unsafe because if a value is `false`, the resulting
+      #   code will have different behaviour or raise an error.
+      #
+      #   [source,ruby]
+      #   ----
+      #   x = false
+      #   x && x.foo  # return false
+      #   x&.foo      # raises NoMethodError
+      #   ----
+      #
       # @example
       #   # bad
       #   foo.bar if foo

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for places where an subset of an array
+      # is calculated based on a `Regexp` match, and suggests `grep` or
+      # `grep_v` instead.
+      #
+      # NOTE: `grep` and `grep_v` were optimized when used without a block
+      # in Ruby 3.0, but may be slower in previous versions.
+      # See https://bugs.ruby-lang.org/issues/17030
+      #
+      # @safety
+      #   Autocorrection is marked as unsafe because `MatchData` will
+      #   not be created by `grep`, but may have previously been relied
+      #   upon after the `match?` or `=~` call.
+      #
+      # @example
+      #   # bad (select or find_all)
+      #   array.select { |x| x.match? /regexp/ }
+      #   array.select { |x| /regexp/.match?(x) }
+      #   array.select { |x| x =~ /regexp/ }
+      #   array.select { |x| /regexp/ =~ x }
+      #
+      #   # bad (reject)
+      #   array.reject { |x| x.match? /regexp/ }
+      #   array.reject { |x| /regexp/.match?(x) }
+      #   array.reject { |x| x =~ /regexp/ }
+      #   array.reject { |x| /regexp/ =~ x }
+      #
+      #   # good
+      #   array.grep(regexp)
+      #   array.grep_v(regexp)
+      class SelectByRegexp < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a regexp match.'
+        RESTRICT_ON_SEND = %i[select find_all reject].freeze
+        REPLACEMENTS = { select: 'grep', find_all: 'grep', reject: 'grep_v' }.freeze
+        REGEXP_METHODS = %i[match? =~].to_set.freeze
+
+        # @!method regexp_match?(node)
+        def_node_matcher :regexp_match?, <<~PATTERN
+          {
+            (block send (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (numblock send $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+          }
+        PATTERN
+
+        # @!method calls_lvar?(node, name)
+        def_node_matcher :calls_lvar?, <<~PATTERN
+          {
+            (send (lvar %1) ...)
+            (send ... (lvar %1))
+            (match-with-lvasgn regexp (lvar %1))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (block_node = node.block_node)
+          return if block_node.body.begin_type?
+          return unless (regexp_method_send_node = extract_send_node(block_node))
+
+          regexp = find_regexp(regexp_method_send_node)
+          register_offense(node, block_node, regexp)
+        end
+
+        private
+
+        def register_offense(node, block_node, regexp)
+          replacement = REPLACEMENTS[node.method_name.to_sym]
+          message = format(MSG, replacement: replacement, original_method: node.method_name)
+
+          add_offense(block_node, message: message) do |corrector|
+            # Only correct if it can be determined what the regexp is
+            if regexp
+              range = range_between(node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+              corrector.replace(range, "#{replacement}(#{regexp.source})")
+            end
+          end
+        end
+
+        def extract_send_node(block_node)
+          return unless (block_arg_name, regexp_method_send_node = regexp_match?(block_node))
+
+          block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+          return unless calls_lvar?(regexp_method_send_node, block_arg_name)
+
+          regexp_method_send_node
+        end
+
+        def find_regexp(node)
+          return node.child_nodes.first if node.match_with_lvasgn_type?
+
+          if node.receiver.lvar_type?
+            node.first_argument
+          elsif node.first_argument.lvar_type?
+            node.receiver
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,11 @@ module RuboCop
       # Sometimes using dig method ends up with just a single
       # argument. In such cases, dig should be replaced with [].
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Enumerable` or does not have a nonstandard implementation
+      #   of `dig`.
+      #
       # @example
       #   # bad
       #   { key: 'value' }.dig(:key)

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

@@ -6,6 +6,19 @@ module RuboCop
       # This cop checks that arrays are sliced with endless ranges instead of
       # `ary[start..-1]` on Ruby 2.6+.
       #
+      # @safety
+      #   This cop is unsafe because `x..-1` and `x..` are only guaranteed to
+      #   be equivalent for `Array#[]`, and the cop cannot determine what class
+      #   the receiver is.
+      #
+      #   For example:
+      #   [source,ruby]
+      #   ----
+      #   sum = proc { |ary| ary.sum }
+      #   sum[-3..-1] # => -6
+      #   sum[-3..] # Hangs forever
+      #   ----
+      #
       # @example
       #   # bad
       #   items[1..-1]

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

@@ -9,6 +9,10 @@ module RuboCop
       # will add a require statement to the top of the file if
       # enabled by RequireEnglish config.
       #
+      # @safety
+      #   Autocorrection is marked as unsafe because if `RequireEnglish` is not
+      #   true, replacing perl-style variables with english variables will break.
+      #
       # @example EnforcedStyle: use_english_names (default)
       #   # good
       #   require 'English' # or this could be in another file.

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

@@ -7,9 +7,10 @@ module RuboCop
       # replaced with a module. Classes should be used only when it makes sense to create
       # instances out of them.
       #
-      # This cop is marked as unsafe, because it is possible that this class is a parent
-      # for some other subclass, monkey-patched with instance methods or
-      # a dummy instance is instantiated from it somewhere.
+      # @safety
+      #   This cop is unsafe, because it is possible that this class is a parent
+      #   for some other subclass, monkey-patched with instance methods or
+      #   a dummy instance is instantiated from it somewhere.
       #
       # @example
       #   # bad

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

@@ -5,8 +5,10 @@ module RuboCop
     module Style
       # Checks for uses of `String#split` with empty string or regexp literal argument.
       #
-      # This cop is marked as unsafe. But probably it's quite unlikely that some other class would
-      # define a `split` method that takes exactly the same arguments.
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is actually a string. If another class has a `split` method with
+      #   different behaviour, it would be registered as a false positive.
       #
       # @example
       #   # bad

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

@@ -23,6 +23,10 @@ module RuboCop
       # This is useful when the receiver is some expression that returns string like `Pathname`
       # instead of a string literal.
       #
+      # @safety
+      #   This cop is unsafe in `aggressive` mode, as it cannot be guaranteed that
+      #   the receiver is actually a string, which can result in a false positive.
+      #
       # @example Mode: aggressive (default)
       #   # bad
       #   email_with_name = user.name + ' <' + user.email + '>'

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop checks for the use of strings as keys in hashes. The use of
       # symbols is preferred instead.
       #
+      # @safety
+      #   This cop is unsafe because while symbols are preferred for hash keys,
+      #   there are instances when string keys are required.
+      #
       # @example
       #   # bad
       #   { 'one' => 1, 'two' => 2, 'three' => 3 }

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

@@ -5,8 +5,9 @@ module RuboCop
     module Style
       # This cop checks for inheritance from Struct.new.
       #
-      # It is marked as unsafe auto-correction because it will change the
-      # inheritance tree (e.g. return value of `Module#ancestors`).
+      # @safety
+      #   Auto-correction is unsafe because it will change the inheritance
+      #   tree (e.g. return value of `Module#ancestors`) of the constant.
       #
       # @example
       #   # bad

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

@@ -4,8 +4,10 @@ module RuboCop
   module Cop
     module Style
       # This cop enforces the use of shorthand-style swapping of 2 variables.
-      # Its autocorrection is marked as unsafe, because it can erroneously remove
-      # the temporary variable which is used later.
+      #
+      # @safety
+      #   Autocorrection is unsafe, because the temporary variable used to
+      #   swap variables will be removed, but may be referred to elsewhere.
       #
       # @example
       #   # bad

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

@@ -8,6 +8,32 @@ module RuboCop
       # If you prefer a style that allows block for method with arguments,
       # please set `true` to `AllowMethodsWithArguments`.
       #
+      # @safety
+      #   This cop is unsafe because `proc`s and blocks work differently
+      #   when additional arguments are passed in. A block will silently
+      #   ignore additional arguments, but a `proc` will raise
+      #   an `ArgumentError`.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Foo
+      #     def bar
+      #       :bar
+      #     end
+      #   end
+      #
+      #   def call(options = {}, &block)
+      #     block.call(Foo.new, options)
+      #   end
+      #
+      #   call { |x| x.bar }
+      #   #=> :bar
+      #   call(&:bar)
+      #   # ArgumentError: wrong number of arguments (given 1, expected 0)
+      #   ----
+      #
       # @example
       #   # bad
       #   something.map { |s| s.upcase }

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

@@ -8,6 +8,25 @@ module RuboCop
       # that comma to be present. Blocks with more than one argument never
       # require a trailing comma.
       #
+      # @safety
+      #   This cop is unsafe because a trailing comma can indicate there are
+      #   more parameters that are not used.
+      #
+      #   For example:
+      #   [source,ruby]
+      #   ----
+      #   # with a trailing comma
+      #   {foo: 1, bar: 2, baz: 3}.map {|key,| key }
+      #   #=> [:foo, :bar, :baz]
+      #
+      #   # without a trailing comma
+      #   {foo: 1, bar: 2, baz: 3}.map {|key| key }
+      #   #=> [[:foo, 1], [:bar, 2], [:baz, 3]]
+      #   ----
+      #
+      #   This can be fixed by replacing the trailing comma with a placeholder
+      #   argument (such as `|key, _value|`).
+      #
       # @example
       #   # bad
       #   add { |foo, bar,| foo + bar }

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

@@ -7,6 +7,26 @@ module RuboCop
       # i.e. comparison operations where the order of expression is reversed.
       # eg. `5 == x`
       #
+      # @safety
+      #   This cop is unsafe because comparison operators can be defined
+      #   differently on different classes, and are not guaranteed to
+      #   have the same result if reversed.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class MyKlass
+      #     def ==(other)
+      #       true
+      #     end
+      #   end
+      #
+      #   obj = MyKlass.new
+      #   obj == 'string'   #=> true
+      #   'string' == obj   #=> false
+      #   ----
+      #
       # @example EnforcedStyle: forbid_for_all_comparison_operators (default)
       #   # bad
       #   99 == foo

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

@@ -9,6 +9,12 @@ module RuboCop
       # receiver.length < 1 and receiver.size == 0 that can be
       # replaced by receiver.empty? and !receiver.empty?.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   has an `empty?` method that is defined in terms of `length`. If there
+      #   is a non-standard class that redefines `length` or `empty?`, the cop
+      #   may register a false positive.
+      #
       # @example
       #   # bad
       #   [1, 2, 3].length == 0

data/lib/rubocop/cop/util.rb

@@ -129,8 +129,8 @@ module RuboCop
         node1.respond_to?(:loc) && node2.respond_to?(:loc) && node1.loc.line == node2.loc.line
       end
 
-      def indent(node)
-        ' ' * node.loc.column
+      def indent(node, offset: 0)
+        ' ' * (node.loc.column + offset)
       end
 
       def to_supported_styles(enforced_style)

data/lib/rubocop/cops_documentation_generator.rb

@@ -33,11 +33,12 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     cops.with_department(department).sort!
   end
 
-  def cops_body(cop, description, examples_objects, pars)
+  def cops_body(cop, description, examples_objects, safety_objects, pars) # rubocop:disable Metrics/AbcSize
     content = h2(cop.cop_name)
     content << required_ruby_version(cop)
     content << properties(cop)
     content << "#{description}\n"
+    content << safety_object(safety_objects) if safety_objects.any? { |s| !s.text.blank? }
     content << examples(examples_objects) if examples_objects.count.positive?
     content << configurations(pars)
     content << references(cop)
@@ -52,6 +53,16 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     end
   end
 
+  def safety_object(safety_object_objects)
+    safety_object_objects.each_with_object(h3('Safety').dup) do |safety_object, content|
+      next if safety_object.text.blank?
+
+      content << "\n" unless content.end_with?("\n\n")
+      content << safety_object.text
+      content << "\n"
+    end
+  end
+
   def required_ruby_version(cop)
     return '' unless cop.respond_to?(:required_minimum_ruby_version)
 
@@ -61,8 +72,8 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   # rubocop:disable Metrics/MethodLength
   def properties(cop)
     header = [
-      'Enabled by default', 'Safe', 'Supports autocorrection', 'VersionAdded',
-      'VersionChanged'
+      'Enabled by default', 'Safe', 'Supports autocorrection', 'Version Added',
+      'Version Changed'
     ]
     autocorrect = if cop.support_autocorrect?
                     "Yes#{' (Unsafe)' unless cop.new(config).safe_autocorrect?}"
@@ -217,12 +228,13 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     ]
     pars = cop_config.reject { |k| non_display_keys.include? k }
     description = 'No documentation'
-    examples_object = []
+    examples_object = safety_object = []
     cop_code(cop) do |code_object|
       description = code_object.docstring unless code_object.docstring.blank?
       examples_object = code_object.tags('example')
+      safety_object = code_object.tags('safety')
     end
-    cops_body(cop, description, examples_object, pars)
+    cops_body(cop, description, examples_object, safety_object, pars)
   end
 
   def cop_code(cop)