rubocop 1.50.2 → 1.68.0

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

@@ -24,7 +24,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
           # check only for method definitions in class/module body
-          return if node.parent && !node.parent.class_type? && !class_eval?(node.parent)
+          return if allowed_context?(node)
 
           message = message(node)
           add_offense(node.loc.selector, message: message) do |corrector|
@@ -34,6 +34,16 @@ module RuboCop
 
         private
 
+        def allowed_context?(node)
+          return false unless (class_node = node.each_ancestor(:class, :block).first)
+
+          (!class_node.class_type? && !class_eval?(class_node)) || define_attr_method?(class_node)
+        end
+
+        def define_attr_method?(node)
+          node.each_descendant(:def).any? { |def_node| def_node.method?(:attr) }
+        end
+
         def autocorrect(corrector, node)
           attr_name, setter = *node.arguments
 

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

@@ -16,31 +16,38 @@ module RuboCop
       #   File.open('file') do |f|
       #     # ...
       #   end
+      #
+      #   # bad
+      #   f = Tempfile.open('temp')
+      #
+      #   # good
+      #   Tempfile.open('temp') do |f|
+      #     # ...
+      #   end
       class AutoResourceCleanup < Base
-        MSG = 'Use the block version of `%<class>s.%<method>s`.'
-
-        TARGET_METHODS = { File: :open }.freeze
+        MSG = 'Use the block version of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[open].freeze
 
-        RESTRICT_ON_SEND = TARGET_METHODS.values.freeze
+        # @!method file_open_method?(node)
+        def_node_matcher :file_open_method?, <<~PATTERN
+          (send (const {nil? cbase} {:File :Tempfile}) :open ...)
+        PATTERN
 
         def on_send(node)
-          TARGET_METHODS.each do |target_class, target_method|
-            next if node.method_name != target_method
+          return if !file_open_method?(node) || cleanup?(node)
 
-            target_receiver = s(:const, nil, target_class)
-            next if node.receiver != target_receiver
+          current = node.receiver.source_range.begin.join(node.selector.end).source
 
-            next if cleanup?(node)
-
-            add_offense(node, message: format(MSG, class: target_class, method: target_method))
-          end
+          add_offense(node, message: format(MSG, current: current))
         end
 
         private
 
         def cleanup?(node)
-          parent = node.parent
-          node.block_argument? || (parent && (parent.block_type? || !parent.lvasgn_type?))
+          return true if node.block_argument?
+          return false unless (parent = node.parent)
+
+          parent.block_type? || !parent.lvasgn_type?
         end
       end
     end

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      #
-      # This cop checks for BEGIN blocks.
+      # Checks for BEGIN blocks.
       #
       # @example
       #   # bad

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

@@ -33,7 +33,7 @@ module RuboCop
         def on_class(class_node)
           @macros_to_rewrite[class_node] = Set.new
 
-          find_macros(class_node.body).each do |_visibility, macros|
+          find_macros(class_node.body).each_value do |macros|
             bisected = find_bisection(macros)
             next unless bisected.any?
 
@@ -74,7 +74,7 @@ module RuboCop
         def find_macros(class_def)
           # Find all the macros (`attr_reader`, `attr_writer`, etc.) in the class body
           # and turn them into `Macro` objects so that they can be processed.
-          return [] if !class_def || class_def.def_type?
+          return {} if !class_def || class_def.def_type?
 
           send_nodes =
             if class_def.send_type?

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer bitwise predicate methods over direct comparison operations.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Integer` object.
+      #
+      # @example
+      #
+      #   # bad - checks any set bits
+      #   (variable & flags).positive?
+      #
+      #   # good
+      #   variable.anybits?(flags)
+      #
+      #   # bad - checks all set bits
+      #   (variable & flags) == flags
+      #
+      #   # good
+      #   variable.allbits?(flags)
+      #
+      #   # bad - checks no set bits
+      #   (variable & flags).zero?
+      #
+      #   # good
+      #   variable.nobits?(flags)
+      #
+      class BitwisePredicate < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Replace with `%<preferred>s` for comparison with bit flags.'
+        RESTRICT_ON_SEND = %i[!= == > >= positive? zero?].freeze
+
+        minimum_target_ruby_version 2.5
+
+        # @!method anybits?(node)
+        def_node_matcher :anybits?, <<~PATTERN
+          {
+            (send #bit_operation? :positive?)
+            (send #bit_operation? :> (int 0))
+            (send #bit_operation? :>= (int 1))
+            (send #bit_operation? :!= (int 0))
+          }
+        PATTERN
+
+        # @!method allbits?(node)
+        def_node_matcher :allbits?, <<~PATTERN
+          {
+            (send (begin (send _ :& _flags)) :== _flags)
+            (send (begin (send _flags :& _)) :== _flags)
+          }
+        PATTERN
+
+        # @!method nobits?(node)
+        def_node_matcher :nobits?, <<~PATTERN
+          {
+            (send #bit_operation? :zero?)
+            (send #bit_operation? :== (int 0))
+          }
+        PATTERN
+
+        # @!method bit_operation?(node)
+        def_node_matcher :bit_operation?, <<~PATTERN
+          (begin
+            (send _ :& _))
+        PATTERN
+
+        def on_send(node)
+          return unless node.receiver.begin_type?
+          return unless (preferred_method = preferred_method(node))
+
+          bit_operation = node.receiver.children.first
+          lhs, _operator, rhs = *bit_operation
+          preferred = "#{lhs.source}.#{preferred_method}(#{rhs.source})"
+
+          add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
+            corrector.replace(node, preferred)
+          end
+        end
+
+        private
+
+        def preferred_method(node)
+          if anybits?(node)
+            'anybits?'
+          elsif allbits?(node)
+            'allbits?'
+          elsif nobits?(node)
+            'nobits?'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -35,7 +35,7 @@ module RuboCop
               unless contents.empty?
                 corrector.replace(
                   contents,
-                  contents.source.gsub(/\A/, '# ').gsub(/\n\n/, "\n#\n").gsub(/\n(?=[^#])/, "\n# ")
+                  contents.source.gsub(/\A/, '# ').gsub("\n\n", "\n#\n").gsub(/\n(?=[^#])/, "\n# ")
                 )
               end
               corrector.remove(eq_end)

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

@@ -176,6 +176,10 @@ module RuboCop
 
         BRACES_REQUIRED_MESSAGE = "Brace delimiters `{...}` required for '%<method_name>s' method."
 
+        def self.autocorrect_incompatible_with
+          [Style::RedundantBegin]
+        end
+
         def on_send(node)
           return unless node.arguments?
           return if node.parenthesized?
@@ -299,13 +303,28 @@ module RuboCop
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
+
+          # It is possible that there is code between the block and the comment
+          # which needs to be preserved and trimmed.
+          pre_comment_range = source_range_before_comment(range, comment)
+
           corrector.remove(range_with_surrounding_space(comment.source_range, side: :right))
-          remove_trailing_whitespace(corrector, range, comment)
-          corrector.insert_after(range, "\n")
+          remove_trailing_whitespace(corrector, pre_comment_range, comment)
+          corrector.insert_after(pre_comment_range, "\n")
 
           corrector.insert_before(block_node, "#{comment.text}\n")
         end
 
+        def source_range_before_comment(range, comment)
+          range = range.end.join(comment.source_range.begin)
+
+          # End the range before any whitespace that precedes the comment
+          trailing_whitespace_count = range.source[/\s+\z/]&.length
+          range = range.adjust(end_pos: -trailing_whitespace_count) if trailing_whitespace_count
+
+          range
+        end
+
         def end_of_chain(node)
           return end_of_chain(node.block_node) if with_block?(node)
           return node unless node.chained?
@@ -341,8 +360,9 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def proper_block_style?(node)
-          return true if require_braces?(node)
+          return true if require_braces?(node) || require_do_end?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)
 
           case style
@@ -352,6 +372,7 @@ module RuboCop
           when :always_braces       then braces_style?(node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def require_braces?(node)
           return false unless node.braces?
@@ -361,6 +382,13 @@ module RuboCop
           end
         end
 
+        def require_do_end?(node)
+          return false if node.braces? || node.multiline?
+          return false unless (resbody = node.each_descendant(:resbody).first)
+
+          resbody.children.first&.array_type?
+        end
+
         def special_method?(method_name)
           allowed_method?(method_name) ||
             matches_allowed_pattern?(method_name) ||
@@ -370,7 +398,8 @@ module RuboCop
         def special_method_proper_block_style?(node)
           method_name = node.method_name
           return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
-          return node.braces? if braces_required_method?(method_name)
+
+          node.braces? if braces_required_method?(method_name)
         end
 
         def braces_required_method?(method_name)
@@ -411,7 +440,7 @@ module RuboCop
         end
 
         def correction_would_break_code?(node)
-          return unless node.keywords?
+          return false unless node.keywords?
 
           node.send_node.arguments? && !node.send_node.parenthesized?
         end
@@ -433,7 +462,7 @@ module RuboCop
         end
 
         def return_value_used?(node)
-          return unless node.parent
+          return false unless node.parent
 
           # If there are parentheses around the block, check if that
           # is being used.
@@ -445,7 +474,7 @@ module RuboCop
         end
 
         def return_value_of_scope?(node)
-          return unless node.parent
+          return false unless node.parent
 
           conditional?(node.parent) || array_or_range?(node.parent) ||
             node.parent.children.last == node

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

@@ -125,7 +125,7 @@ module RuboCop
           when :==, :eql?, :equal?
             find_target_in_equality_node(node)
           when :===
-            node.arguments.first
+            node.first_argument
           when :include?, :cover?
             find_target_in_include_or_cover_node(node)
           when :match, :match?, :=~
@@ -134,7 +134,7 @@ module RuboCop
         end
 
         def find_target_in_equality_node(node)
-          argument = node.arguments.first
+          argument = node.first_argument
           receiver = node.receiver
           return unless argument && receiver
 
@@ -152,7 +152,7 @@ module RuboCop
         end
 
         def find_target_in_match_node(node)
-          argument = node.arguments.first
+          argument = node.first_argument
           receiver = node.receiver
           return unless receiver
 
@@ -185,7 +185,7 @@ module RuboCop
         def condition_from_send_node(node, target)
           case node.method_name
           when :is_a?
-            node.arguments.first if node.receiver == target
+            node.first_argument if node.receiver == target
           when :==, :eql?, :equal?
             condition_from_equality_node(node, target)
           when :=~, :match, :match?
@@ -230,7 +230,7 @@ module RuboCop
 
         def branch_conditions(node)
           conditions = []
-          while node&.if_type?
+          while node&.if_type? && !node.ternary?
             conditions << node.condition
             node = node.else_branch
           end

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

@@ -139,7 +139,7 @@ module RuboCop
         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)

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,9 +5,14 @@ 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.
       #
+      # @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
       #   var.class == Date
@@ -18,53 +23,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'
-      #   var.class.to_s == 'Date'
-      #   var.class.inspect == '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'
-      #   var.class.to_s == 'Date'
-      #   var.class.inspect == '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'
-      #   var.class.to_s == 'Date'
-      #   var.class.inspect == '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'
-      #   var.class.to_s == 'Date'
-      #   var.class.inspect == 'Date'
+      #   def eq(other)
+      #     self.class.eq(other.class) && name.eq(other.name)
+      #   end
       #
       class ClassEqualityComparison < Base
         include RangeHelp
@@ -91,6 +74,8 @@ module RuboCop
                     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_argument = (class_name = class_name(class_node, node)) ? "(#{class_name})" : ''
 

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

@@ -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
@@ -21,6 +21,9 @@ module RuboCop
       #   array.reject(&:nil?)
       #   array.reject { |e| e.nil? }
       #   array.select { |e| !e.nil? }
+      #   array.filter { |e| !e.nil? }
+      #   array.grep_v(nil)
+      #   array.grep_v(NilClass)
       #
       #   # good
       #   array.compact
@@ -29,24 +32,31 @@ module RuboCop
       #   hash.reject!(&:nil?)
       #   hash.reject! { |k, v| v.nil? }
       #   hash.select! { |k, v| !v.nil? }
+      #   hash.filter! { |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 reject! select select!].freeze
+        RESTRICT_ON_SEND = %i[reject reject! select select! filter filter! grep_v].freeze
         TO_ENUM_METHODS = %i[to_enum lazy].freeze
+        FILTER_METHODS = %i[filter filter!].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 :reject!}
             (block_pass
               (sym :nil?)))
         PATTERN
@@ -54,26 +64,33 @@ module RuboCop
         # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
-            (send
+            (call
               !nil? {:reject :reject!})
             $(args ...)
-            (send
+            (call
               $(lvar _) :nil?))
         PATTERN
 
         # @!method select_method?(node)
         def_node_matcher :select_method?, <<~PATTERN
           (block
-            (send
-              !nil? {:select :select!})
+            (call
+              !nil? {:select :select! :filter :filter!})
             $(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 if target_ruby_version < 2.6 && FILTER_METHODS.include?(node.method_name)
           return unless (range = offense_range(node))
+          return if allowed_receiver?(node.receiver)
           return if target_ruby_version <= 3.0 && to_enum_method?(node)
 
           good = good_method_name(node)
@@ -81,11 +98,13 @@ module RuboCop
 
           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
@@ -99,6 +118,7 @@ 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?

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

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