rubocop 1.20.0 → 1.22.2

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for places where an subset of an Enumerable (array,
+      # range, set, etc.; see note below) is calculated based on a `Regexp`
+      # match, and suggests `grep` or `grep_v` instead.
+      #
+      # NOTE: Hashes do not behave as you may expect with `grep`, which
+      # means that `hash.grep` is not equivalent to `hash.select`. Although
+      # RuboCop is limited by static analysis, this cop attempts to avoid
+      # registering an offense when the receiver is a hash (hash literal,
+      # `Hash.new`, `Hash#[]`, or `to_h`/`to_hash`).
+      #
+      # 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.
+      #
+      #   Additionally, the cop cannot guarantee that the receiver of
+      #   `select` or `reject` is actually an array by static analysis,
+      #   so the correction may not be actually equivalent.
+      #
+      # @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
+
+        # Returns true if a node appears to return a hash
+        # @!method creates_hash?(node)
+        def_node_matcher :creates_hash?, <<~PATTERN
+          {
+            (send (const _ :Hash) {:new :[]} ...)
+            (block (send (const _ :Hash) :new ...) ...)
+            (send _ { :to_h :to_hash } ...)
+          }
+        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 if receiver_allowed?(block_node.receiver)
+          return unless (regexp_method_send_node = extract_send_node(block_node))
+          return if match_predicate_without_receiver?(regexp_method_send_node)
+
+          regexp = find_regexp(regexp_method_send_node)
+          register_offense(node, block_node, regexp)
+        end
+
+        private
+
+        def receiver_allowed?(node)
+          return false unless node
+
+          node.hash_type? || creates_hash?(node)
+        end
+
+        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
+
+        def match_predicate_without_receiver?(node)
+          node.send_type? && node.method?(:match?) && node.receiver.nil?
+        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
@@ -60,8 +61,7 @@ module RuboCop
           return false if nodes.empty?
 
           nodes.all? do |node|
-            node_visibility(node) == :public &&
-              node.defs_type? ||
+            (node_visibility(node) == :public && node.defs_type?) ||
               sclass_convertible_to_module?(node) ||
               node.equals_asgn? ||
               extend_call?(node)

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 + '>'
@@ -93,7 +97,7 @@ module RuboCop
 
         def offensive_for_mode?(receiver_node)
           mode = cop_config['Mode'].to_sym
-          mode == :aggressive || mode == :conservative && receiver_node.str_type?
+          mode == :aggressive || (mode == :conservative && receiver_node.str_type?)
         end
 
         def line_end_concatenation?(node)

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

@@ -192,7 +192,7 @@ module RuboCop
 
         def allowed_method_name?(node)
           allowed_method_names.include?(node.method_name) ||
-            exact_name_match? && !names_match?(node)
+            (exact_name_match? && !names_match?(node))
         end
 
         def allowed_writer?(method_name)

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
@@ -58,14 +78,11 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Reverse the order of the operands `%<source>s`.'
-
         REVERSE_COMPARISON = { '<' => '>', '<=' => '>=', '>' => '<', '>=' => '<=' }.freeze
-
         EQUALITY_OPERATORS = %i[== !=].freeze
-
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
-
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
+        RESTRICT_ON_SEND = RuboCop::AST::Node::COMPARISON_OPERATORS
 
         # @!method file_constant_equal_program_name?(node)
         def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
@@ -74,7 +91,7 @@ module RuboCop
 
         def on_send(node)
           return unless yoda_compatible_condition?(node)
-          return if equality_only? && non_equality_operator?(node) ||
+          return if (equality_only? && non_equality_operator?(node)) ||
                     file_constant_equal_program_name?(node)
 
           valid_yoda?(node) || add_offense(node) do |corrector|
@@ -102,8 +119,8 @@ module RuboCop
           lhs = node.receiver
           rhs = node.first_argument
 
-          return true if lhs.literal? && rhs.literal? ||
-                         !lhs.literal? && !rhs.literal? ||
+          return true if (lhs.literal? && rhs.literal?) ||
+                         (!lhs.literal? && !rhs.literal?) ||
                          interpolation?(lhs)
 
           enforce_yoda? ? lhs.literal? : rhs.literal?

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

@@ -113,7 +113,8 @@ module RuboCop
         if needs_escaping?(string) && compatible_external_encoding_for?(string)
           string.inspect
         else
-          "'#{string.gsub('\\') { '\\\\' }}'"
+          # In a single-quoted strings, double quotes don't need to be escaped
+          "'#{string.gsub('\"', '"').gsub('\\') { '\\\\' }}'"
         end
       end
 
@@ -125,12 +126,22 @@ module RuboCop
         StringInterpreter.interpret(string)
       end
 
+      def line(node_or_range)
+        if node_or_range.respond_to?(:line)
+          node_or_range.line
+        elsif node_or_range.respond_to?(:loc)
+          node_or_range.loc.line
+        end
+      end
+
       def same_line?(node1, node2)
-        node1.respond_to?(:loc) && node2.respond_to?(:loc) && node1.loc.line == node2.loc.line
+        line1 = line(node1)
+        line2 = line(node2)
+        line1 && line2 && line1 == line2
       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)