rubocop 1.18.0 → 1.56.0

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

@@ -3,8 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of `Object#instance_of?` instead of class comparison
+      # Enforces the use of `Object#instance_of?` instead of class comparison
       # for equality.
+      # `==`, `equal?`, and `eql?` custom method definitions are allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad
@@ -16,32 +18,66 @@ module RuboCop
       #   # good
       #   var.instance_of?(Date)
       #
+      # @example AllowedMethods: ['==', 'equal?', 'eql?'] (default)
+      #   # good
+      #   def ==(other)
+      #     self.class == other.class && name == other.name
+      #   end
+      #
+      #   def equal?(other)
+      #     self.class.equal?(other.class) && name.equal?(other.name)
+      #   end
+      #
+      #   def eql?(other)
+      #     self.class.eql?(other.class) && name.eql?(other.name)
+      #   end
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # bad
+      #   def eq(other)
+      #     self.class.eq(other.class) && name.eq(other.name)
+      #   end
+      #
+      # @example AllowedPatterns: ['eq']
+      #   # good
+      #   def eq(other)
+      #     self.class.eq(other.class) && name.eq(other.name)
+      #   end
+      #
       class ClassEqualityComparison < Base
         include RangeHelp
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
-        MSG = 'Use `instance_of?(%<class_name>s)` instead of comparing classes.'
+        MSG = 'Use `instance_of?%<class_argument>s` instead of comparing classes.'
 
         RESTRICT_ON_SEND = %i[== equal? eql?].freeze
+        CLASS_NAME_METHODS = %i[name to_s inspect].freeze
 
         # @!method class_comparison_candidate?(node)
         def_node_matcher :class_comparison_candidate?, <<~PATTERN
           (send
-            {$(send _ :class) (send $(send _ :class) :name)}
+            {$(send _ :class) (send $(send _ :class) #class_name_method?)}
             {:== :equal? :eql?} $_)
         PATTERN
 
         def on_send(node)
           def_node = node.each_ancestor(:def, :defs).first
-          return if def_node && ignored_method?(def_node.method_name)
+          return if def_node &&
+                    (allowed_method?(def_node.method_name) ||
+                    matches_allowed_pattern?(def_node.method_name))
 
           class_comparison_candidate?(node) do |receiver_node, class_node|
+            return if class_node.dstr_type?
+
             range = offense_range(receiver_node, node)
-            class_name = class_name(class_node, node)
+            class_argument = (class_name = class_name(class_node, node)) ? "(#{class_name})" : ''
 
-            add_offense(range, message: format(MSG, class_name: class_name)) do |corrector|
-              corrector.replace(range, "instance_of?(#{class_name})")
+            add_offense(range, message: format(MSG, class_argument: class_argument)) do |corrector|
+              next unless class_name
+
+              corrector.replace(range, "instance_of?#{class_argument}")
             end
           end
         end
@@ -49,13 +85,39 @@ module RuboCop
         private
 
         def class_name(class_node, node)
-          if node.children.first.method?(:name)
-            return class_node.receiver.source if class_node.receiver
+          if class_name_method?(node.children.first.method_name)
+            if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
+              return receiver.source
+            end
 
-            class_node.source.delete('"').delete("'")
-          else
-            class_node.source
+            if class_node.str_type?
+              value = trim_string_quotes(class_node)
+              value.prepend('::') if require_cbase?(class_node)
+              return value
+            elsif unable_to_determine_type?(class_node)
+              # When a variable or return value of a method is used, it returns nil
+              # because the type is not known and cannot be suggested.
+              return
+            end
           end
+
+          class_node.source
+        end
+
+        def class_name_method?(method_name)
+          CLASS_NAME_METHODS.include?(method_name)
+        end
+
+        def require_cbase?(class_node)
+          class_node.each_ancestor(:class, :module).any?
+        end
+
+        def unable_to_determine_type?(class_node)
+          class_node.variable? || class_node.call_type?
+        end
+
+        def trim_string_quotes(class_node)
+          class_node.source.delete('"').delete("'")
         end
 
         def offense_range(receiver_node, node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of the class/module name instead of
+      # Checks for uses of the class/module name instead of
       # self, when defining class/module methods.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces using `def self.method_name` or `class << self` to define class methods.
+      # Enforces using `def self.method_name` or `class << self` to define class methods.
       #
       # @example EnforcedStyle: def_self (default)
       #   # bad
@@ -70,7 +70,7 @@ module RuboCop
 
         def on_sclass(node)
           return unless def_self_style?
-          return unless node.identifier.source == 'self'
+          return unless node.identifier.self_type?
           return unless all_methods_public?(node)
 
           add_offense(node, message: MSG_SCLASS) do |corrector|
@@ -80,6 +80,7 @@ module RuboCop
 
         def on_defs(node)
           return if def_self_style?
+          return unless node.receiver.self_type?
 
           message = format(MSG, preferred: 'class << self')
           add_offense(node, message: message)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of class variables. Offenses
+      # Checks for uses of class variables. Offenses
       # are signaled only on assignment to class variables to
       # reduce the number of offenses that would be reported.
       #

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

@@ -3,43 +3,66 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where custom logic on rejection nils from arrays
+      # Checks for places where custom logic on rejection nils from arrays
       # and hashes can be replaced with `{Array,Hash}#{compact,compact!}`.
       #
-      # It is marked as unsafe by default because false positives may occur in the
-      # nil check of block arguments to the receiver object.
-      # For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
-      # and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
-      # when the receiver is a hash object.
+      # @safety
+      #   It is unsafe by default because false positives may occur in the
+      #   `nil` check of block arguments to the receiver object. Additionally,
+      #   we can't know the type of the receiver object for sure, which may
+      #   result in false positives as well.
+      #
+      #   For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
+      #   and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
+      #   when the receiver is a hash object.
       #
       # @example
       #   # bad
+      #   array.reject(&:nil?)
+      #   array.delete_if(&:nil?)
       #   array.reject { |e| e.nil? }
+      #   array.delete_if { |e| e.nil? }
       #   array.select { |e| !e.nil? }
       #
       #   # good
       #   array.compact
       #
       #   # bad
+      #   hash.reject!(&:nil?)
       #   hash.reject! { |k, v| v.nil? }
       #   hash.select! { |k, v| !v.nil? }
       #
       #   # good
       #   hash.compact!
       #
+      # @example AllowedReceivers: ['params']
+      #   # good
+      #   params.reject(&:nil?)
+      #
       class CollectionCompact < Base
+        include AllowedReceivers
         include RangeHelp
         extend AutoCorrector
+        extend TargetRubyVersion
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+        RESTRICT_ON_SEND = %i[reject delete_if reject! select select!].freeze
+        TO_ENUM_METHODS = %i[to_enum lazy].freeze
 
-        RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
+        minimum_target_ruby_version 2.4
+
+        # @!method reject_method_with_block_pass?(node)
+        def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
+          (send !nil? {:reject :delete_if :reject!}
+            (block_pass
+              (sym :nil?)))
+        PATTERN
 
         # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
-              _ ${:reject :reject!})
+              !nil? {:reject :delete_if :reject!})
             $(args ...)
             (send
               $(lvar _) :nil?))
@@ -49,7 +72,7 @@ module RuboCop
         def_node_matcher :select_method?, <<~PATTERN
           (block
             (send
-              _ ${:select :select!})
+              !nil? {:select :select!})
             $(args ...)
             (send
               (send
@@ -57,16 +80,13 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          block_node = node.parent
-          return unless block_node&.block_type?
-
-          return unless (method_name, args, receiver =
-                           reject_method?(block_node) || select_method?(block_node))
-
-          return unless args.last.source == receiver.source
+          return unless (range = offense_range(node))
+          return if allowed_receiver?(node.receiver)
+          if (target_ruby_version <= 3.0 || node.method?(:delete_if)) && to_enum_method?(node)
+            return
+          end
 
-          range = offense_range(node, block_node)
-          good = good_method_name(method_name)
+          good = good_method_name(node)
           message = format(MSG, good: good, bad: range.source)
 
           add_offense(range, message: message) { |corrector| corrector.replace(range, good) }
@@ -74,16 +94,38 @@ module RuboCop
 
         private
 
-        def good_method_name(method_name)
-          if method_name.to_s.end_with?('!')
+        def offense_range(node)
+          if reject_method_with_block_pass?(node)
+            range(node, node)
+          else
+            block_node = node.parent
+
+            return unless block_node&.block_type?
+            unless (args, receiver = reject_method?(block_node) || select_method?(block_node))
+              return
+            end
+            return unless args.last.source == receiver.source
+
+            range(node, block_node)
+          end
+        end
+
+        def to_enum_method?(node)
+          return false unless node.receiver.send_type?
+
+          TO_ENUM_METHODS.include?(node.receiver.method_name)
+        end
+
+        def good_method_name(node)
+          if node.bang_method?
             'compact!'
           else
             'compact'
           end
         end
 
-        def offense_range(send_node, block_node)
-          range_between(send_node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+        def range(begin_pos_node, end_pos_node)
+          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.source_range.end_pos)
         end
       end
     end

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

@@ -3,13 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of consistent method names
+      # Enforces the use of consistent method names
       # from the Enumerable module.
       #
-      # Unfortunately we cannot actually know if a method is from
-      # Enumerable or not (static analysis limitation), so this cop
-      # can yield some false positives.
-      #
       # You can customize the mapping from undesired method to desired method.
       #
       # e.g. to use `detect` over `find`:
@@ -18,9 +14,14 @@ module RuboCop
       #     PreferredMethods:
       #       find: detect
       #
-      # The default mapping for `PreferredMethods` behaves as follows.
+      # @safety
+      #   This cop is unsafe because it finds methods by name, without actually
+      #   being able to determine if the receiver is an Enumerable or not, so
+      #   this cop may register false positives.
       #
       # @example
+      #   # These examples are based on the default mapping for `PreferredMethods`.
+      #
       #   # bad
       #   items.collect
       #   items.collect!
@@ -47,6 +48,8 @@ module RuboCop
           check_method_node(node.send_node)
         end
 
+        alias on_numblock on_block
+
         def on_send(node)
           return unless implicit_block?(node)
 
@@ -68,7 +71,8 @@ module RuboCop
           return false unless node.arguments.any?
 
           node.last_argument.block_pass_type? ||
-            node.last_argument.sym_type? && methods_accepting_symbol.include?(node.method_name.to_s)
+            (node.last_argument.sym_type? &&
+            methods_accepting_symbol.include?(node.method_name.to_s))
         end
 
         def message(node)

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for methods invoked via the :: operator instead
-      # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
+      # Checks for methods invoked via the `::` operator instead
+      # of the `.` operator (like `FileUtils::rmdir` instead of `FileUtils.rmdir`).
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for class methods that are defined using the `::`
+      # Checks for class methods that are defined using the `::`
       # operator instead of the `.` operator.
       #
       # @example

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

@@ -3,12 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where multiple consecutive loops over the same data
+      # Checks for places where multiple consecutive loops over the same data
       # can be combined into a single loop. It is very likely that combining them
       # will make the code more efficient and more concise.
       #
-      # It is marked as unsafe, because the first loop might modify
-      # a state that the second loop depends on; these two aren't combinable.
+      # @safety
+      #   The cop is unsafe, because the first loop might modify state that the
+      #   second loop depends on; these two aren't combinable.
       #
       # @example
       #   # bad
@@ -56,36 +57,59 @@ module RuboCop
       #   end
       #
       class CombinableLoops < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
         MSG = 'Combine this loop with the previous loop.'
 
         def on_block(node)
           return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)
+          return unless same_collection_looping_block?(node, node.left_sibling)
+          return unless node.body && node.left_sibling.body
 
-          add_offense(node) if same_collection_looping?(node, node.left_sibling)
+          add_offense(node) do |corrector|
+            combine_with_left_sibling(corrector, node)
+          end
         end
 
+        alias on_numblock on_block
+
         def on_for(node)
           return unless node.parent&.begin_type?
+          return unless same_collection_looping_for?(node, node.left_sibling)
 
-          sibling = node.left_sibling
-          add_offense(node) if sibling&.for_type? && node.collection == sibling.collection
+          add_offense(node) do |corrector|
+            combine_with_left_sibling(corrector, node)
+          end
         end
 
         private
 
         def collection_looping_method?(node)
-          # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
-          method_name = node.send_node.method_name.to_s
+          method_name = node.method_name
           method_name.start_with?('each') || method_name.end_with?('_each')
         end
 
-        def same_collection_looping?(node, sibling)
-          sibling&.block_type? &&
+        def same_collection_looping_block?(node, sibling)
+          (sibling&.block_type? || sibling&.numblock_type?) &&
             sibling.send_node.method?(node.method_name) &&
-            sibling.send_node.receiver == node.send_node.receiver &&
+            sibling.receiver == node.receiver &&
             sibling.send_node.arguments == node.send_node.arguments
         end
+
+        def same_collection_looping_for?(node, sibling)
+          sibling&.for_type? && node.collection == sibling.collection
+        end
+
+        def combine_with_left_sibling(corrector, node)
+          corrector.replace(
+            node.left_sibling.body,
+            "#{node.left_sibling.body.source}\n#{node.body.source}"
+          )
+          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces using `` or %x around command literals.
+      # Enforces using `` or %x around command literals.
       #
       # @example EnforcedStyle: backticks (default)
       #   # bad
@@ -148,7 +148,7 @@ module RuboCop
         end
 
         def contains_backtick?(node)
-          /`/.match?(node_body(node))
+          node_body(node).include?('`')
         end
 
         def node_body(node)

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

@@ -3,16 +3,19 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that comment annotation keywords are written according
+      # Checks that comment annotation keywords are written according
       # to guidelines.
       #
+      # Annotation keywords can be specified by overriding the cop's `Keywords`
+      # configuration. Keywords are allowed to be single words or phrases.
+      #
       # NOTE: With a multiline comment block (where each line is only a
       # comment), only the first line will be able to register an offense, even
       # if an annotation keyword starts another line. This is done to prevent
       # incorrect registering of keywords (eg. `review`) inside a paragraph as an
       # annotation.
       #
-      # @example
+      # @example RequireColon: true (default)
       #   # bad
       #   # TODO make better
       #
@@ -36,14 +39,35 @@ module RuboCop
       #
       #   # good
       #   # OPTIMIZE: does not work
+      #
+      # @example RequireColon: false
+      #   # bad
+      #   # TODO: make better
+      #
+      #   # good
+      #   # TODO make better
+      #
+      #   # bad
+      #   # fixme does not work
+      #
+      #   # good
+      #   # FIXME does not work
+      #
+      #   # bad
+      #   # Optimize does not work
+      #
+      #   # good
+      #   # OPTIMIZE does not work
       class CommentAnnotation < Base
-        include AnnotationComment
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Annotation keywords like `%<keyword>s` should be all ' \
-              'upper case, followed by a colon, and a space, ' \
-              'then a note describing the problem.'
+        MSG_COLON_STYLE = 'Annotation keywords like `%<keyword>s` should be all ' \
+                          'upper case, followed by a colon, and a space, ' \
+                          'then a note describing the problem.'
+        MSG_SPACE_STYLE = 'Annotation keywords like `%<keyword>s` should be all ' \
+                          'upper case, followed by a space, ' \
+                          'then a note describing the problem.'
         MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, is missing a note.'
 
         def on_new_investigation
@@ -51,25 +75,27 @@ module RuboCop
             next unless first_comment_line?(processed_source.comments, index) ||
                         inline_comment?(comment)
 
-            margin, first_word, colon, space, note = split_comment(comment)
-            next unless annotation?(comment) && !correct_annotation?(first_word, colon, space, note)
+            annotation = AnnotationComment.new(comment, keywords)
+            next unless annotation.annotation? && !annotation.correct?(colon: requires_colon?)
 
-            range = annotation_range(comment, margin, first_word, colon, space)
-
-            register_offense(range, note, first_word)
+            register_offense(annotation)
           end
         end
 
         private
 
-        def register_offense(range, note, first_word)
-          add_offense(
-            range,
-            message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
-          ) do |corrector|
-            next if note.nil?
+        def register_offense(annotation)
+          range = annotation_range(annotation)
+          message = if annotation.note
+                      requires_colon? ? MSG_COLON_STYLE : MSG_SPACE_STYLE
+                    else
+                      MISSING_NOTE
+                    end
+
+          add_offense(range, message: format(message, keyword: annotation.keyword)) do |corrector|
+            next if annotation.note.nil?
 
-            corrector.replace(range, "#{first_word.upcase}: ")
+            correct_offense(corrector, range, annotation.keyword)
           end
         end
 
@@ -78,21 +104,25 @@ module RuboCop
         end
 
         def inline_comment?(comment)
-          !comment_line?(comment.loc.expression.source_line)
+          !comment_line?(comment.source_range.source_line)
         end
 
-        def annotation_range(comment, margin, first_word, colon, space)
-          start = comment.loc.expression.begin_pos + margin.length
-          length = concat_length(first_word, colon, space)
-          range_between(start, start + length)
+        def annotation_range(annotation)
+          range_between(*annotation.bounds)
+        end
+
+        def correct_offense(corrector, range, keyword)
+          return corrector.replace(range, "#{keyword.upcase}: ") if requires_colon?
+
+          corrector.replace(range, "#{keyword.upcase} ")
         end
 
-        def concat_length(*args)
-          args.reduce(0) { |acc, elem| acc + elem.to_s.length }
+        def requires_colon?
+          cop_config['RequireColon']
         end
 
-        def correct_annotation?(first_word, colon, space, note)
-          keyword?(first_word) && (colon && space && note || !colon && !note)
+        def keywords
+          cop_config['Keywords']
         end
       end
     end