rubocop 1.46.0 → 1.52.1

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # Enforces the use of `Object#instance_of?` instead of class comparison
       # for equality.
-      # `==`, `equal?`, and `eql?` methods are allowed by default.
+      # `==`, `equal?`, and `eql?` custom method definitions are allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
       # @example
@@ -18,45 +18,31 @@ module RuboCop
       #   # good
       #   var.instance_of?(Date)
       #
-      # @example AllowedMethods: [] (default)
+      # @example AllowedMethods: ['==', 'equal?', 'eql?'] (default)
       #   # good
-      #   var.instance_of?(Date)
+      #   def ==(other)
+      #     self.class == other.class && name == other.name
+      #   end
       #
-      #   # bad
-      #   var.class == Date
-      #   var.class.equal?(Date)
-      #   var.class.eql?(Date)
-      #   var.class.name == 'Date'
+      #   def equal?(other)
+      #     self.class.equal?(other.class) && name.equal?(other.name)
+      #   end
       #
-      # @example AllowedMethods: [`==`]
-      #   # good
-      #   var.instance_of?(Date)
-      #   var.class == Date
-      #   var.class.name == 'Date'
-      #
-      #   # bad
-      #   var.class.equal?(Date)
-      #   var.class.eql?(Date)
+      #   def eql?(other)
+      #     self.class.eql?(other.class) && name.eql?(other.name)
+      #   end
       #
       # @example AllowedPatterns: [] (default)
-      #   # good
-      #   var.instance_of?(Date)
-      #
       #   # bad
-      #   var.class == Date
-      #   var.class.equal?(Date)
-      #   var.class.eql?(Date)
-      #   var.class.name == 'Date'
+      #   def eq(other)
+      #     self.class.eq(other.class) && name.eq(other.name)
+      #   end
       #
       # @example AllowedPatterns: ['eq']
       #   # good
-      #   var.instance_of?(Date)
-      #   var.class.equal?(Date)
-      #   var.class.eql?(Date)
-      #
-      #   # bad
-      #   var.class == Date
-      #   var.class.name == 'Date'
+      #   def eq(other)
+      #     self.class.eq(other.class) && name.eq(other.name)
+      #   end
       #
       class ClassEqualityComparison < Base
         include RangeHelp
@@ -64,14 +50,15 @@ module RuboCop
         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
 
@@ -83,10 +70,12 @@ module RuboCop
 
           class_comparison_candidate?(node) do |receiver_node, class_node|
             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
@@ -94,19 +83,41 @@ 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
 
             if class_node.str_type?
-              value = class_node.source.delete('"').delete("'")
-              value.prepend('::') if class_node.each_ancestor(:class, :module).any?
+              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)
           range_between(receiver_node.loc.selector.begin_pos, node.source_range.end_pos)
         end

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

@@ -9,8 +9,8 @@ module RuboCop
       # @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.
+      #   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,7 +19,9 @@ module RuboCop
       # @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
@@ -33,17 +35,25 @@ module RuboCop
       #   # 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 reject! select select!].freeze
+        RESTRICT_ON_SEND = %i[reject delete_if reject! select select!].freeze
         TO_ENUM_METHODS = %i[to_enum lazy].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!}
+          (send !nil? {:reject :delete_if :reject!}
             (block_pass
               (sym :nil?)))
         PATTERN
@@ -52,7 +62,7 @@ module RuboCop
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
-              !nil? {:reject :reject!})
+              !nil? {:reject :delete_if :reject!})
             $(args ...)
             (send
               $(lvar _) :nil?))
@@ -71,7 +81,10 @@ module RuboCop
 
         def on_send(node)
           return unless (range = offense_range(node))
-          return if target_ruby_version <= 3.0 && to_enum_method?(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)
@@ -112,7 +125,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.expression.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/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,38 +57,58 @@ 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)
 
-          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)
+        def same_collection_looping_block?(node, sibling)
           (sibling&.block_type? || sibling&.numblock_type?) &&
             sibling.send_node.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.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/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

@@ -66,7 +66,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(comment.loc.expression, newlines: false)
+            range = range_with_surrounding_space(comment.source_range, newlines: false)
             corrector.remove(range)
 
             unless matched_keyword == 'end'
@@ -84,7 +84,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/concat_array_literals.rb

@@ -38,7 +38,7 @@ module RuboCop
           offense = offense_range(node)
           current = offense.source
 
-          if node.arguments.any?(&:percent_literal?)
+          if (use_percent_literal = node.arguments.any?(&:percent_literal?))
             if percent_literals_includes_only_basic_literals?(node)
               prefer = preferred_method(node)
               message = format(MSG, prefer: prefer, current: current)
@@ -51,7 +51,15 @@ module RuboCop
           end
 
           add_offense(offense, message: message) do |corrector|
-            corrector.replace(offense, prefer)
+            if use_percent_literal
+              corrector.replace(offense, prefer)
+            else
+              corrector.replace(node.loc.selector, 'push')
+              node.arguments.each do |argument|
+                corrector.remove(argument.loc.begin)
+                corrector.remove(argument.loc.end)
+              end
+            end
           end
         end
         # rubocop:enable Metrics

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

@@ -350,7 +350,7 @@ module RuboCop
         end
 
         def ternary_condition?(node)
-          [node, node.children.first].any? { |n| n.if_type? && n.ternary? }
+          [node, node.children.first].compact.any? { |n| n.if_type? && n.ternary? }
         end
 
         def lhs_all_match?(branches)
@@ -386,7 +386,7 @@ module RuboCop
         def allowed_statements?(branches)
           return false unless branches.all?
 
-          statements = branches.map { |branch| tail(branch) }.compact
+          statements = branches.filter_map { |branch| tail(branch) }
 
           lhs_all_match?(statements) && statements.none?(&:masgn_type?) &&
             assignment_types_match?(*statements)
@@ -450,7 +450,7 @@ module RuboCop
         end
 
         def white_space_range(node, column)
-          expression = node.loc.expression
+          expression = node.source_range
           begin_pos = expression.begin_pos - (expression.column - column - 2)
 
           Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
@@ -458,9 +458,9 @@ module RuboCop
 
         def assignment(node)
           *_, condition = *node
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.loc.expression.begin_pos,
-                                    condition.loc.expression.begin_pos)
+          Parser::Source::Range.new(node.source_range.source_buffer,
+                                    node.source_range.begin_pos,
+                                    condition.source_range.begin_pos)
         end
 
         def correct_if_branches(corrector, cop, node)
@@ -565,7 +565,7 @@ module RuboCop
           end
 
           def move_assignment_inside_condition(corrector, node)
-            column = node.loc.expression.column
+            column = node.source_range.column
             *_var, condition = *node
             assignment = assignment(node)
 
@@ -616,7 +616,7 @@ module RuboCop
           end
 
           def move_assignment_inside_condition(corrector, node)
-            column = node.loc.expression.column
+            column = node.source_range.column
             *_var, condition = *node
             assignment = assignment(node)
 

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

@@ -8,8 +8,11 @@ module RuboCop
       # The default regexp for an acceptable copyright notice can be found in
       # config/default.yml. The default can be changed as follows:
       #
-      #  Style/Copyright:
-      #    Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
+      # [source,yaml]
+      # ----
+      # Style/Copyright:
+      #   Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
+      # ----
       #
       # This regex string is treated as an unanchored regex. For each file
       # that RuboCop scans, a comment that matches this regex must be found or
@@ -82,7 +85,7 @@ module RuboCop
         def notice_found?(processed_source)
           notice_found = false
           notice_regexp = Regexp.new(notice)
-          processed_source.each_token do |token|
+          processed_source.tokens.each do |token|
             break unless token.comment?
 
             notice_found = notice_regexp.match?(token.text)

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for inheritance from `Data.define` to avoid creating the anonymous parent class.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it will change the inheritance
+      #   tree (e.g. return value of `Module#ancestors`) of the constant.
+      #
+      # @example
+      #   # bad
+      #   class Person < Data.define(:first_name, :last_name)
+      #     def age
+      #       42
+      #     end
+      #   end
+      #
+      #   # good
+      #   Person = Data.define(:first_name, :last_name) do
+      #     def age
+      #       42
+      #     end
+      #   end
+      class DataInheritance < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = "Don't extend an instance initialized by `Data.define`. " \
+              'Use a block to customize the class.'
+
+        minimum_target_ruby_version 3.2
+
+        def on_class(node)
+          return unless data_define?(node.parent_class)
+
+          add_offense(node.parent_class.source_range) do |corrector|
+            corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
+            corrector.replace(node.loc.operator, '=')
+
+            correct_parent(node.parent_class, corrector)
+          end
+        end
+
+        # @!method data_define?(node)
+        def_node_matcher :data_define?, <<~PATTERN
+          {(send (const {nil? cbase} :Data) :define ...)
+           (block (send (const {nil? cbase} :Data) :define ...) ...)}
+        PATTERN
+
+        private
+
+        def correct_parent(parent, corrector)
+          if parent.block_type?
+            corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))
+          elsif (class_node = parent.parent).body.nil?
+            corrector.remove(range_for_empty_class_body(class_node, parent))
+          else
+            corrector.insert_after(parent, ' do')
+          end
+        end
+
+        def range_for_empty_class_body(class_node, data_define)
+          if class_node.single_line?
+            range_between(data_define.source_range.end_pos, class_node.source_range.end_pos)
+          else
+            range_by_whole_lines(class_node.loc.end, include_final_newline: true)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for places where the `#__dir__` method can replace more
+      # Checks for places where the `#\_\_dir\_\_` method can replace more
       # complex constructs to retrieve a canonicalized absolute path to the
       # current file.
       #

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer to use `Dir.empty?('path/to/dir')` when checking if a directory is empty.
+      #
+      # @example
+      #   # bad
+      #   Dir.entries('path/to/dir').size == 2
+      #   Dir.children('path/to/dir').empty?
+      #   Dir.children('path/to/dir').size == 0
+      #   Dir.each_child('path/to/dir').none?
+      #
+      #   # good
+      #   Dir.empty?('path/to/dir')
+      #
+      class DirEmpty < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<replacement>s` instead.'
+        RESTRICT_ON_SEND = %i[== != > empty? none?].freeze
+
+        minimum_target_ruby_version 2.4
+
+        # @!method offensive?(node)
+        def_node_matcher :offensive?, <<~PATTERN
+          {
+            (send (send (send $(const {nil? cbase} :Dir) :entries $_) :size) {:== :!= :>} (int 2))
+            (send (send (send $(const {nil? cbase} :Dir) :children $_) :size) {:== :!= :>} (int 0))
+            (send (send $(const {nil? cbase} :Dir) :children $_) :empty?)
+            (send (send $(const {nil? cbase} :Dir) :each_child $_) :none?)
+          }
+        PATTERN
+
+        def on_send(node)
+          offensive?(node) do |const_node, arg_node|
+            replacement = "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})"
+            add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def bang(node)
+          '!' if %i[!= >].include? node.method_name
+        end
+      end
+    end
+  end
+end

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

@@ -34,8 +34,8 @@ module RuboCop
         extend AutoCorrector
 
         # rubocop:enable Lint/RedundantCopDisableDirective
-        MSG = 'Rubocop disable/enable directives are not permitted.'
-        MSG_FOR_COPS = 'Rubocop disable/enable directives for %<cops>s are not permitted.'
+        MSG = 'RuboCop disable/enable directives are not permitted.'
+        MSG_FOR_COPS = 'RuboCop disable/enable directives for %<cops>s are not permitted.'
 
         def on_new_investigation
           processed_source.comments.each do |comment|

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

@@ -111,12 +111,12 @@ module RuboCop
           return if comments.none?
 
           regexp = comment_regexp(arg_node)
-          comments.any? { |comment| regexp.match?(comment) } || regexp.match?(comments.join)
+          comments.any?(regexp) || regexp.match?(comments.join)
         end
 
         def preceding_comment_blocks(node)
           # Collect comments in the method call, but outside the heredoc
-          comments = processed_source.each_comment_in_lines(node.loc.expression.line_span)
+          comments = processed_source.each_comment_in_lines(node.source_range.line_span)
 
           comments.each_with_object({}) do |comment, hash|
             merge_adjacent_comments(comment.text, comment.loc.line, hash)

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

@@ -10,7 +10,7 @@ module RuboCop
       # declarations.
       #
       # The documentation requirement is annulled if the class or module has
-      # a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the
+      # a `#:nodoc:` comment next to it. Likewise, `#:nodoc: all` does the
       # same for all its children.
       #
       # @example
@@ -110,7 +110,7 @@ module RuboCop
           return if nodoc_self_or_outer_module?(node)
           return if include_statement_only?(body)
 
-          range = range_between(node.loc.expression.begin_pos, node.loc.name.end_pos)
+          range = range_between(node.source_range.begin_pos, node.loc.name.end_pos)
           message = format(MSG, type: node.type, identifier: identifier(node))
           add_offense(range, message: message)
         end
@@ -178,13 +178,19 @@ module RuboCop
         def identifier(node)
           # Get the fully qualified identifier for a class/module
           nodes = [node, *node.each_ancestor(:class, :module)]
-          nodes.reverse_each.flat_map { |n| qualify_const(n.identifier) }.join('::')
+          identifier = nodes.reverse_each.flat_map { |n| qualify_const(n.identifier) }.join('::')
+
+          identifier.sub('::::', '::')
         end
 
         def qualify_const(node)
-          return if node.nil? || node.cbase_type? || node.self_type? || node.send_type?
+          return if node.nil?
 
-          [qualify_const(node.namespace), node.short_name].compact
+          if node.cbase_type? || node.self_type? || node.call_type? || node.variable?
+            node.source
+          else
+            [qualify_const(node.namespace), node.short_name].compact
+          end
         end
       end
     end

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

@@ -103,12 +103,12 @@ module RuboCop
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
           return parent if parent.def_type? || parent.defs_type?
-          return node.parent.child_nodes.first if define_mehod?(parent)
+          return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)
         end
 
-        def define_mehod?(node)
+        def define_method?(node)
           return false unless node.block_type?
 
           child = node.child_nodes.first