rubocop 1.53.0 → 1.90.0

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies usages of `arr[0]` and `arr[-1]` and suggests to change
+      # them to use `arr.first` and `arr.last` instead.
+      #
+      # The cop is disabled by default due to safety concerns.
+      #
+      # @safety
+      #   This cop is unsafe because `[0]` or `[-1]` can be called on a Hash,
+      #   which returns a value for `0` or `-1` key, but changing these to use
+      #   `.first` or `.last` will return first/last tuple instead. Also, String
+      #   does not implement `first`/`last` methods.
+      #
+      # @example
+      #   # bad
+      #   arr[0]
+      #   arr[-1]
+      #
+      #   # good
+      #   arr.first
+      #   arr.last
+      #   arr[0] = 2
+      #   arr[0][-2]
+      #
+      class ArrayFirstLast < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred>s`.'
+        RESTRICT_ON_SEND = %i[[]].freeze
+
+        # rubocop:disable-next Metrics/AbcSize
+        def on_send(node)
+          return unless node.arguments.size == 1 && node.first_argument.int_type?
+
+          value = node.first_argument.value
+          return unless [0, -1].include?(value)
+
+          node = innermost_braces_node(node)
+          return if node.parent && brace_method?(node.parent)
+          return if compound_assignment_target?(node)
+
+          preferred = preferred_name(value)
+          offense_range = find_offense_range(node)
+
+          add_offense(offense_range, message: format(MSG, preferred: preferred)) do |corrector|
+            corrector.replace(offense_range, preferred_value(node, preferred))
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def preferred_name(value)
+          value.zero? ? 'first' : 'last'
+        end
+
+        def preferred_value(node, value)
+          value = ".#{value}" unless node.loc.dot
+          value
+        end
+
+        def find_offense_range(node)
+          if node.loc.dot
+            node.loc.selector.join(node.source_range.end)
+          else
+            node.loc.selector
+          end
+        end
+
+        def innermost_braces_node(node)
+          node = node.receiver while node.receiver.send_type? && node.receiver.method?(:[])
+          node
+        end
+
+        def brace_method?(node)
+          node.send_type? && (node.method?(:[]) || node.method?(:[]=))
+        end
+
+        # `arr[0] += 1` etc. would autocorrect to `arr.first += 1`, which calls the
+        # nonexistent `first=`/`last=` setter and raises `NoMethodError`.
+        def compound_assignment_target?(node)
+          node.parent&.type?(:op_asgn, :or_asgn, :and_asgn) && node.parent.children.first == node
+        end
+      end
+    end
+  end
+end

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

@@ -5,11 +5,35 @@ module RuboCop
     module Style
       # In Ruby 3.1, `Array#intersect?` has been added.
       #
-      # This cop identifies places where `(array1 & array2).any?`
-      # can be replaced by `array1.intersect?(array2)`.
+      # This cop identifies places where:
       #
-      # The `array1.intersect?(array2)` method is faster than
-      # `(array1 & array2).any?` and is more readable.
+      # * `(array1 & array2).any?`
+      # * `(array1.intersection(array2)).any?`
+      # * `array1.any? { |elem| array2.member?(elem) }`
+      # * `(array1 & array2).count > 0`
+      # * `(array1 & array2).size > 0`
+      #
+      # can be replaced with `array1.intersect?(array2)`.
+      #
+      # `array1.intersect?(array2)` is faster and more readable.
+      #
+      # In cases like the following, compatibility is not ensured,
+      # so it will not be detected when using block argument.
+      #
+      # [source,ruby]
+      # ----
+      # ([1] & [1,2]).any? { |x| false }    # => false
+      # [1].intersect?([1,2]) { |x| false } # => true
+      # ----
+      #
+      # NOTE: Although `Array#intersection` can take zero or multiple arguments,
+      # only cases where exactly one argument is provided can be replaced with
+      # `Array#intersect?` and are handled by this cop.
+      #
+      # NOTE: In the block form, `include?` is only detected when its receiver is
+      # an array literal, because `include?` is defined with different semantics
+      # on many non-array classes (e.g. `String#include?` checks for substrings).
+      # `member?` does not have this restriction.
       #
       # @safety
       #   This cop cannot guarantee that `array1` and `array2` are
@@ -19,11 +43,34 @@ module RuboCop
       #   # bad
       #   (array1 & array2).any?
       #   (array1 & array2).empty?
+      #   (array1 & array2).none?
+      #
+      #   # bad
+      #   array1.intersection(array2).any?
+      #   array1.intersection(array2).empty?
+      #   array1.intersection(array2).none?
+      #
+      #   # bad
+      #   array1.any? { |elem| array2.member?(elem) }
+      #   array1.none? { |elem| [1, 2].include?(elem) }
       #
       #   # good
       #   array1.intersect?(array2)
       #   !array1.intersect?(array2)
       #
+      #   # bad
+      #   (array1 & array2).count > 0
+      #   (array1 & array2).count.positive?
+      #   (array1 & array2).count != 0
+      #
+      #   (array1 & array2).count == 0
+      #   (array1 & array2).count.zero?
+      #
+      #   # good
+      #   array1.intersect?(array2)
+      #
+      #   !array1.intersect?(array2)
+      #
       # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
       #   # good
       #   (array1 & array2).present?
@@ -43,51 +90,103 @@ module RuboCop
 
         minimum_target_ruby_version 3.1
 
-        # @!method regular_bad_intersection_check?(node)
-        def_node_matcher :regular_bad_intersection_check?, <<~PATTERN
-          (send
-            (begin
-              (send $(...) :& $(...))
-            ) ${:any? :empty?}
+        PREDICATES = %i[any? empty? none?].to_set.freeze
+        ACTIVE_SUPPORT_PREDICATES = (PREDICATES + %i[present? blank?]).freeze
+
+        ARRAY_SIZE_METHODS = %i[count length size].to_set.freeze
+
+        # @!method bad_intersection_check?(node, predicates)
+        def_node_matcher :bad_intersection_check?, <<~PATTERN
+          $(call
+            {
+              (begin (send $_ :& $_))
+              (call $!nil? :intersection $_)
+            }
+            $%1
           )
         PATTERN
 
-        # @!method active_support_bad_intersection_check?(node)
-        def_node_matcher :active_support_bad_intersection_check?, <<~PATTERN
-          (send
-            (begin
-              (send $(...) :& $(...))
-            ) ${:present? :any? :blank? :empty?}
+        # @!method intersection_size_check?(node, predicates)
+        def_node_matcher :intersection_size_check?, <<~PATTERN
+          (call
+            $(call
+              {
+                (begin (send $_ :& $_))
+                (call $!nil? :intersection $_)
+              }
+              %ARRAY_SIZE_METHODS
+            )
+            {$:> (int 0) | $:positive? | $:!= (int 0) | $:== (int 0) | $:zero?}
           )
         PATTERN
 
-        MSG = 'Use `%<negated>s%<receiver>s.intersect?(%<argument>s)` ' \
-              'instead of `(%<receiver>s & %<argument>s).%<method_name>s`.'
-        STRAIGHT_METHODS = %i[present? any?].freeze
-        NEGATED_METHODS = %i[blank? empty?].freeze
+        # @!method any_none_block_intersection(node)
+        def_node_matcher :any_none_block_intersection, <<~PATTERN
+          {
+            (block
+              (call $_receiver ${:any? :none?})
+              (args (arg _key))
+              (send $!nil? ${:member? :include?} (lvar _key))
+            )
+            (numblock
+              (call $_receiver ${:any? :none?}) 1
+              (send $!nil? ${:member? :include?} (lvar :_1))
+            )
+            (itblock
+              (call $_receiver ${:any? :none?}) :it
+              (send $!nil? ${:member? :include?} (lvar :it))
+            )
+          }
+        PATTERN
+
+        MSG = 'Use `%<replacement>s` instead of `%<existing>s`.'
+        STRAIGHT_METHODS = %i[present? any? > positive? !=].freeze
+        NEGATED_METHODS = %i[blank? empty? none? == zero?].freeze
         RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
 
         def on_send(node)
-          return unless (receiver, argument, method_name = bad_intersection_check?(node))
+          return if node.block_literal?
+          return unless (dot_node, receiver, argument, method_name = bad_intersection?(node))
 
-          message = message(receiver.source, argument.source, method_name)
+          dot = dot_node.loc.dot.source
+          bang = straight?(method_name) ? '' : '!'
+          # `a&.intersection(b)&.none?` returns `nil` when `a` is `nil`, but the negated
+          # rewrite `!a&.intersect?(b)` returns `true` there, flipping the result.
+          return if bang == '!' && dot == '&.'
 
-          add_offense(node, message: message) do |corrector|
-            if straight?(method_name)
-              corrector.replace(node, "#{receiver.source}.intersect?(#{argument.source})")
-            else
-              corrector.replace(node, "!#{receiver.source}.intersect?(#{argument.source})")
-            end
-          end
+          replacement = "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})"
+
+          register_offense(node, replacement)
+        end
+        alias on_csend on_send
+
+        def on_block(node)
+          return unless (captures = any_none_block_intersection(node))
+
+          receiver, method_name, argument, block_method = captures
+          return if uncorrectable_block_intersection?(node, method_name, argument, block_method)
+
+          dot = node.send_node.loc.dot.source
+          bang = method_name == :any? ? '' : '!'
+          replacement = "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})"
+
+          register_offense(node, replacement)
         end
+        alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
-        def bad_intersection_check?(node)
+        def bad_intersection?(node)
+          bad_intersection_check?(node, bad_intersection_predicates) ||
+            intersection_size_check?(node)
+        end
+
+        def bad_intersection_predicates
           if active_support_extensions_enabled?
-            active_support_bad_intersection_check?(node)
+            ACTIVE_SUPPORT_PREDICATES
           else
-            regular_bad_intersection_check?(node)
+            PREDICATES
           end
         end
 
@@ -95,15 +194,23 @@ module RuboCop
           STRAIGHT_METHODS.include?(method_name.to_sym)
         end
 
-        def message(receiver, argument, method_name)
-          negated = straight?(method_name) ? '' : '!'
-          format(
-            MSG,
-            negated: negated,
-            receiver: receiver,
-            argument: argument,
-            method_name: method_name
-          )
+        def uncorrectable_block_intersection?(node, method_name, argument, block_method)
+          # `a&.none? { |elem| b.include?(elem) }` returns `nil` when `a` is `nil`,
+          # but the negated rewrite `!a&.intersect?(b)` returns `true` there, flipping the result.
+          return true if method_name == :none? && node.send_node.safe_navigation?
+
+          # `include?` is defined with different semantics on many non-array classes
+          # (e.g. `String#include?` checks for substrings), so it is only a reliable
+          # signal of an intersection check when the receiver is an array literal.
+          block_method == :include? && !argument.array_type?
+        end
+
+        def register_offense(node, replacement)
+          message = format(MSG, replacement: replacement, existing: node.source)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
         end
       end
     end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use `include?(element)` instead of `intersect?([element])`.
+      #
+      # @safety
+      #   The receiver might not be an array.
+      #
+      # @example
+      #   # bad
+      #   array.intersect?([element])
+      #
+      #   # good
+      #   array.include?(element)
+      class ArrayIntersectWithSingleElement < Base
+        extend AutoCorrector
+
+        MSG = 'Use `include?(element)` instead of `intersect?([element])`.'
+
+        RESTRICT_ON_SEND = %i[intersect?].freeze
+
+        # @!method single_element(node)
+        def_node_matcher :single_element, <<~PATTERN
+          (send _ _ $(array $_))
+        PATTERN
+
+        def on_send(node)
+          array, element = single_element(node)
+          return unless array
+          # `[*foo]` is not a single element: the splat can expand to any number of
+          # elements, so `intersect?([*foo])` is not equivalent to `include?(*foo)`.
+          return if element.splat_type?
+
+          add_offense(
+            node.source_range.with(begin_pos: node.loc.selector.begin_pos)
+          ) do |corrector|
+            corrector.replace(node.loc.selector, 'include?')
+            corrector.replace(
+              array,
+              array.percent_literal? ? element.value.inspect : element.source
+            )
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -3,9 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of "*" as a substitute for _join_.
+      # Checks for uses of `*` as a substitute for `Array#join`.
+      # Using `join` is clearer about intent and more readable than
+      # overloading the `*` operator for string conversion.
       #
-      # Not all cases can reliably checked, due to Ruby's dynamic
+      # Not all cases can be reliably checked, due to Ruby's dynamic
       # types, so we consider only cases when the first argument is an
       # array literal or the second is a string literal.
       #

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

@@ -4,8 +4,11 @@ module RuboCop
   module Cop
     module Style
       # Checks for non-ascii (non-English) characters
-      # in comments. You could set an array of allowed non-ascii chars in
-      # `AllowedChars` attribute (copyright notice "©" by default).
+      # in comments. Non-ascii characters can cause issues with
+      # portability and encoding across different environments
+      # and editors. You could set an array of allowed non-ascii
+      # chars in `AllowedChars` attribute (copyright notice "©"
+      # by default).
       #
       # @example
       #   # bad
@@ -49,7 +52,7 @@ module RuboCop
         end
 
         def allowed_non_ascii_chars
-          cop_config['AllowedChars'] || []
+          @allowed_non_ascii_chars ||= (cop_config['AllowedChars'] || []).freeze
         end
       end
     end

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

@@ -3,10 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of Module#attr.
+      # Checks for uses of `Module#attr`. The `attr` method has confusing
+      # behavior: with a single argument it creates a reader (like `attr_reader`),
+      # but with a second boolean argument it creates an accessor (deprecated in
+      # Ruby 1.9). Use `attr_reader` or `attr_accessor` to make intent explicit.
       #
       # @example
-      #   # bad - creates a single attribute accessor (deprecated in Ruby 1.9)
+      #   # bad
       #   attr :something, true
       #   attr :one, :two, :three # behaves as attr_reader
       #

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks if usage of %() or %Q() matches configuration.
+      # Checks if usage of `%()` or `%Q()` matches configuration.
+      # Consistent use of one style makes the codebase easier
+      # to read.
       #
       # @example EnforcedStyle: bare_percent (default)
       #   # bad
@@ -41,8 +43,7 @@ module RuboCop
 
         def check(node)
           return if node.heredoc?
-          return unless node.loc.respond_to?(:begin)
-          return unless node.loc.begin
+          return unless node.loc?(:begin)
 
           source = node.loc.begin.source
           if requires_percent_q?(source)

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for BEGIN blocks.
+      # Checks for `BEGIN` blocks. They are Perl-style constructs that execute
+      # code before the rest of the file is parsed, making the control flow
+      # harder to follow and reason about.
       #
       # @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,106 @@
+# 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
+
+        # rubocop:disable-next Metrics/AbcSize
+        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 = if preferred_method == 'allbits?' && lhs.source == node.first_argument.source
+                        "#{rhs.source}.allbits?(#{lhs.source})"
+                      else
+                        "#{lhs.source}.#{preferred_method}(#{rhs.source})"
+                      end
+
+          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