rubocop 1.30.1 → 1.64.0

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

@@ -11,7 +11,7 @@ module RuboCop
       #
       #   Moving from compact to nested children requires knowledge of whether the
       #   outer parent is a module or a class. Moving from nested to compact requires
-      #   verification that the outer parent is defined elsewhere. Rubocop does not
+      #   verification that the outer parent is defined elsewhere. RuboCop does not
       #   have the knowledge to perform either operation safely and thus requires
       #   manual oversight.
       #
@@ -31,6 +31,7 @@ module RuboCop
       #
       # The compact style is only forced for classes/modules with one child.
       class ClassAndModuleChildren < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
         extend AutoCorrector
@@ -59,7 +60,7 @@ module RuboCop
         end
 
         def nest_definition(corrector, node)
-          padding = ((' ' * indent_width) + leading_spaces(node)).to_s
+          padding = indentation(node) + leading_spaces(node)
           padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
 
           replace_namespace_keyword(corrector, node)
@@ -117,15 +118,11 @@ module RuboCop
         end
 
         def remove_end(corrector, body)
-          range = range_between(
-            body.loc.end.begin_pos - leading_spaces(body).size,
-            body.loc.end.end_pos + 1
-          )
-          corrector.remove(range)
-        end
+          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
+          range = range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
 
-        def configured_indentation_width
-          config.for_badge(Layout::IndentationWidth.badge).fetch('Width', 2)
+          corrector.remove(range)
         end
 
         def unindent(corrector, node)
@@ -141,12 +138,8 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def indent_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def check_style(node, body)
-          return if node.identifier.children[0]&.cbase_type?
+          return if node.identifier.namespace&.cbase_type?
 
           if style == :nested
             check_nested_style(node)
@@ -185,7 +178,7 @@ module RuboCop
         end
 
         def compact_node_name?(node)
-          /::/.match?(node.identifier.source)
+          node.identifier.source.include?('::')
         end
       end
     end

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

@@ -40,6 +40,7 @@ module RuboCop
             corrector.replace(node.loc.selector, replacement)
           end
         end
+        alias on_csend on_send
 
         def message(node)
           if node.method?(:is_a?)

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

@@ -5,6 +5,13 @@ module RuboCop
     module Style
       # 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.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because there is no guarantee that
+      #   the constant `Foo` exists when autocorrecting `var.class.name == 'Foo'` to
+      #   `var.instance_of?(Foo)`.
       #
       # @example
       #   # bad
@@ -16,32 +23,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_argument: class_argument)) do |corrector|
+              next unless class_name
 
-            add_offense(range, message: format(MSG, class_name: class_name)) do |corrector|
-              corrector.replace(range, "instance_of?(#{class_name})")
+              corrector.replace(range, "instance_of?#{class_argument}")
             end
           end
         end
@@ -49,13 +90,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_definitions.rb

@@ -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

@@ -54,9 +54,9 @@ module RuboCop
         end
 
         def on_send(node)
-          add_offense(
-            node.first_argument, message: format(MSG, class_var: node.first_argument.source)
-          )
+          return unless (first_argument = node.first_argument)
+
+          add_offense(first_argument, message: format(MSG, class_var: first_argument.source))
         end
       end
     end

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

@@ -8,7 +8,9 @@ module RuboCop
       #
       # @safety
       #   It is unsafe by default because false positives may occur in the
-      #   `nil` check of block arguments to the receiver object.
+      #   `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
@@ -19,29 +21,41 @@ module RuboCop
       #   array.reject(&:nil?)
       #   array.reject { |e| e.nil? }
       #   array.select { |e| !e.nil? }
+      #   array.grep_v(nil)
+      #   array.grep_v(NilClass)
       #
       #   # good
       #   array.compact
       #
       #   # bad
       #   hash.reject!(&:nil?)
+      #   array.delete_if(&:nil?)
       #   hash.reject! { |k, v| v.nil? }
+      #   array.delete_if { |e| e.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! grep_v].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 :reject!}
+          (call !nil? {:reject :delete_if :reject!}
             (block_pass
               (sym :nil?)))
         PATTERN
@@ -49,37 +63,48 @@ module RuboCop
         # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
-            (send
-              !nil? {:reject :reject!})
+            (call
+              !nil? {:reject :delete_if :reject!})
             $(args ...)
-            (send
+            (call
               $(lvar _) :nil?))
         PATTERN
 
         # @!method select_method?(node)
         def_node_matcher :select_method?, <<~PATTERN
           (block
-            (send
+            (call
               !nil? {:select :select!})
             $(args ...)
-            (send
-              (send
+            (call
+              (call
                 $(lvar _) :nil?) :!))
         PATTERN
 
+        # @!method grep_v_with_nil?(node)
+        def_node_matcher :grep_v_with_nil?, <<~PATTERN
+          (send _ :grep_v {(nil) (const {nil? cbase} :NilClass)})
+        PATTERN
+
         def on_send(node)
           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
 
           good = good_method_name(node)
           message = format(MSG, good: good, bad: range.source)
 
           add_offense(range, message: message) { |corrector| corrector.replace(range, good) }
         end
+        alias on_csend on_send
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def offense_range(node)
-          if reject_method_with_block_pass?(node)
+          if reject_method_with_block_pass?(node) || grep_v_with_nil?(node)
             range(node, node)
           else
             block_node = node.parent
@@ -93,9 +118,16 @@ module RuboCop
             range(node, block_node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        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?
+          if node.bang_method? || node.method?(:delete_if)
             'compact!'
           else
             'compact'
@@ -103,7 +135,7 @@ module RuboCop
         end
 
         def range(begin_pos_node, end_pos_node)
-          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.end.end_pos)
+          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

@@ -25,6 +25,7 @@ module RuboCop
       #   # bad
       #   items.collect
       #   items.collect!
+      #   items.collect_concat
       #   items.inject
       #   items.detect
       #   items.find_all
@@ -33,6 +34,7 @@ module RuboCop
       #   # good
       #   items.map
       #   items.map!
+      #   items.flat_map
       #   items.reduce
       #   items.find
       #   items.select
@@ -48,6 +50,8 @@ module RuboCop
           check_method_node(node.send_node)
         end
 
+        alias on_numblock on_block
+
         def on_send(node)
           return unless implicit_block?(node)
 

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # 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/combinable_loops.rb

@@ -57,36 +57,66 @@ module RuboCop
       #   end
       #
       class CombinableLoops < Base
+        extend AutoCorrector
+
         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.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? &&
-            sibling.send_node.method?(node.method_name) &&
+        def same_collection_looping_block?(node, sibling)
+          return false if sibling.nil? || (!sibling.block_type? && !sibling.numblock_type?)
+
+          sibling.method?(node.method_name) &&
             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.remove(node.left_sibling.body.source_range.end.join(node.left_sibling.loc.end))
+          corrector.remove(node.source_range.begin.join(node.body.source_range.begin))
+
+          correct_end_of_block(corrector, node)
+        end
+
+        def correct_end_of_block(corrector, node)
+          return unless node.left_sibling.respond_to?(:braces?)
+          return if node.right_sibling&.block_type? || node.right_sibling&.numblock_type?
+
+          end_of_block = node.left_sibling.braces? ? '}' : ' end'
+          corrector.remove(node.loc.end)
+          corrector.insert_before(node.source_range.end, end_of_block)
+        end
       end
     end
   end

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

@@ -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

@@ -104,7 +104,7 @@ 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(annotation)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../directive_comment'
+
 module RuboCop
   module Cop
     module Style
@@ -49,8 +51,9 @@ module RuboCop
         KEYWORDS = %w[begin class def end module].freeze
         KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
 
-        ALLOWED_COMMENTS = %w[:nodoc: :yields: rubocop:disable rubocop:todo].freeze
-        ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
+        ALLOWED_COMMENTS = %w[:nodoc: :yields:].freeze
+        ALLOWED_COMMENT_REGEXES = (ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ } +
+                                   [DirectiveComment::DIRECTIVE_COMMENT_REGEXP]).freeze
 
         REGEXP = /(?<keyword>\S+).*#/.freeze
 
@@ -66,7 +69,7 @@ module RuboCop
 
         def register_offense(comment, matched_keyword)
           add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
-            range = range_with_surrounding_space(range: comment.loc.expression, newlines: false)
+            range = range_with_surrounding_space(comment.source_range, newlines: false)
             corrector.remove(range)
 
             unless matched_keyword == 'end'
@@ -84,7 +87,7 @@ module RuboCop
         end
 
         def source_line(comment)
-          comment.location.expression.source_line
+          comment.source_range.source_line
         end
       end
     end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `Comparable#clamp` instead of comparison by minimum and maximum.
+      #
+      # This cop supports autocorrection for `if/elsif/else` bad style only.
+      # Because `ArgumentError` occurs if the minimum and maximum of `clamp` arguments are reversed.
+      # When these are variables, it is not possible to determine which is the minimum and maximum:
+      #
+      # [source,ruby]
+      # ----
+      # [1, [2, 3].max].min # => 1
+      # 1.clamp(3, 1)       # => min argument must be smaller than max argument (ArgumentError)
+      # ----
+      #
+      # @example
+      #
+      #   # bad
+      #   [[x, low].max, high].min
+      #
+      #   # bad
+      #   if x < low
+      #     low
+      #   elsif high < x
+      #     high
+      #   else
+      #     x
+      #   end
+      #
+      #   # good
+      #   x.clamp(low, high)
+      #
+      class ComparableClamp < Base
+        include Alignment
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
+
+        MSG = 'Use `%<prefer>s` instead of `if/elsif/else`.'
+        MSG_MIN_MAX = 'Use `Comparable#clamp` instead.'
+        RESTRICT_ON_SEND = %i[min max].freeze
+
+        # @!method if_elsif_else_condition?(node)
+        def_node_matcher :if_elsif_else_condition?, <<~PATTERN
+          {
+            (if (send _x :< _min) _min (if (send _max :< _x) _max _x))
+            (if (send _min :> _x) _min (if (send _max :< _x) _max _x))
+            (if (send _x :< _min) _min (if (send _x :> _max) _max _x))
+            (if (send _min :> _x) _min (if (send _x :> _max) _max _x))
+            (if (send _max :< _x) _max (if (send _x :< _min) _min _x))
+            (if (send _x :> _max) _max (if (send _x :< _min) _min _x))
+            (if (send _max :< _x) _max (if (send _min :> _x) _min _x))
+            (if (send _x :> _max) _max (if (send _min :> _x) _min _x))
+          }
+        PATTERN
+
+        # @!method array_min_max?(node)
+        def_node_matcher :array_min_max?, <<~PATTERN
+          {
+            (send
+              (array
+                (send (array _ _) :max) _) :min)
+            (send
+              (array
+                _ (send (array _ _) :max)) :min)
+            (send
+              (array
+                (send (array _ _) :min) _) :max)
+            (send
+              (array
+                _ (send (array _ _) :min)) :max)
+          }
+        PATTERN
+
+        def on_if(node)
+          return unless if_elsif_else_condition?(node)
+
+          if_body, elsif_body, else_body = *node.branches
+
+          else_body_source = else_body.source
+
+          if min_condition?(node.condition, else_body_source)
+            min = if_body.source
+            max = elsif_body.source
+          else
+            min = elsif_body.source
+            max = if_body.source
+          end
+
+          prefer = "#{else_body_source}.clamp(#{min}, #{max})"
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            autocorrect(corrector, node, prefer)
+          end
+        end
+
+        def on_send(node)
+          return unless array_min_max?(node)
+
+          add_offense(node, message: MSG_MIN_MAX)
+        end
+
+        private
+
+        def autocorrect(corrector, node, prefer)
+          if node.elsif?
+            corrector.insert_before(node, "else\n")
+            corrector.replace(node, "#{indentation(node)}#{prefer}")
+          else
+            corrector.replace(node, prefer)
+          end
+        end
+
+        def min_condition?(if_condition, else_body)
+          lhs, op, rhs = *if_condition
+
+          (lhs.source == else_body && op == :<) || (rhs.source == else_body && op == :>)
+        end
+      end
+    end
+  end
+end