rubocop 1.67.0 → 1.73.0

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

@@ -70,6 +70,7 @@ module RuboCop
       #     private :bar, :baz
       #     private *%i[qux quux]
       #     private *METHOD_NAMES
+      #     private *private_methods
       #
       #   end
       #
@@ -80,6 +81,7 @@ module RuboCop
       #     private :bar, :baz
       #     private *%i[qux quux]
       #     private *METHOD_NAMES
+      #     private *private_methods
       #
       #   end
       #
@@ -110,6 +112,26 @@ module RuboCop
       #     private attr :quux
       #
       #   end
+      #
+      # @example AllowModifiersOnAliasMethod: true (default)
+      #   # good
+      #   class Foo
+      #
+      #     public alias_method :bar, :foo
+      #     protected alias_method :baz, :foo
+      #     private alias_method :qux, :foo
+      #
+      #   end
+      #
+      # @example AllowModifiersOnAliasMethod: false
+      #   # bad
+      #   class Foo
+      #
+      #     public alias_method :bar, :foo
+      #     protected alias_method :baz, :foo
+      #     private alias_method :qux, :foo
+      #
+      #   end
       class AccessModifierDeclarations < Base
         extend AutoCorrector
 
@@ -128,26 +150,27 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[private protected public module_function].freeze
 
-        ALLOWED_NODE_TYPES = %i[pair block].freeze
-
         # @!method access_modifier_with_symbol?(node)
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
           (send nil? {:private :protected :public :module_function}
-            {(sym _) (splat {#percent_symbol_array? const})}
+            {(sym _)+ (splat {#percent_symbol_array? const send})}
           )
         PATTERN
 
         # @!method access_modifier_with_attr?(node)
         def_node_matcher :access_modifier_with_attr?, <<~PATTERN
           (send nil? {:private :protected :public :module_function}
-            (send nil? {:attr :attr_reader :attr_writer :attr_accessor} _))
+            (send nil? {:attr :attr_reader :attr_writer :attr_accessor} _+))
+        PATTERN
+
+        # @!method access_modifier_with_alias_method?, <<~PATTERN
+        def_node_matcher :access_modifier_with_alias_method?, <<~PATTERN
+          (send nil? {:private :protected :public :module_function}
+            (send nil? :alias_method _ _))
         PATTERN
 
         def on_send(node)
-          return unless node.access_modifier?
-          return if ALLOWED_NODE_TYPES.include?(node.parent&.type)
-          return if allow_modifiers_on_symbols?(node)
-          return if allow_modifiers_on_attrs?(node)
+          return if allowed?(node)
 
           if offense?(node)
             add_offense(node.loc.selector) do |corrector|
@@ -161,15 +184,23 @@ module RuboCop
 
         private
 
+        def allowed?(node)
+          !node.access_modifier? ||
+            node.parent&.type?(:pair, :any_block) ||
+            allow_modifiers_on_symbols?(node) ||
+            allow_modifiers_on_attrs?(node) ||
+            allow_modifiers_on_alias_method?(node)
+        end
+
         def autocorrect(corrector, node)
           case style
           when :group
-            def_node = find_corresponding_def_node(node)
-            return unless def_node
+            def_nodes = find_corresponding_def_nodes(node)
+            return unless def_nodes.any?
 
-            replace_def(corrector, node, def_node)
+            replace_defs(corrector, node, def_nodes)
           when :inline
-            remove_node(corrector, node)
+            remove_nodes(corrector, node)
             select_grouped_def_nodes(node).each do |grouped_def_node|
               insert_inline_modifier(corrector, grouped_def_node, node.method_name)
             end
@@ -188,12 +219,23 @@ module RuboCop
           cop_config['AllowModifiersOnAttrs'] && access_modifier_with_attr?(node)
         end
 
+        def allow_modifiers_on_alias_method?(node)
+          cop_config['AllowModifiersOnAliasMethod'] && access_modifier_with_alias_method?(node)
+        end
+
         def offense?(node)
           (group_style? && access_modifier_is_inlined?(node) &&
-            !right_siblings_same_inline_method?(node)) ||
+            !node.parent&.if_type? && !right_siblings_same_inline_method?(node)) ||
             (inline_style? && access_modifier_is_not_inlined?(node))
         end
 
+        def correctable_group_offense?(node)
+          return false unless group_style?
+          return false if allowed?(node)
+
+          access_modifier_is_inlined?(node) && find_corresponding_def_nodes(node).any?
+        end
+
         def group_style?
           style == :group
         end
@@ -212,7 +254,11 @@ module RuboCop
 
         def right_siblings_same_inline_method?(node)
           node.right_siblings.any? do |sibling|
-            sibling.send_type? && sibling.method?(node.method_name) && !sibling.arguments.empty?
+            sibling.send_type? &&
+              correctable_group_offense?(sibling) &&
+              sibling.method?(node.method_name) &&
+              !sibling.arguments.empty? &&
+              find_corresponding_def_nodes(sibling).any?
           end
         end
 
@@ -226,14 +272,22 @@ module RuboCop
           end
         end
 
-        def find_corresponding_def_node(node)
+        def find_corresponding_def_nodes(node)
           if access_modifier_with_symbol?(node)
-            method_name = node.first_argument.respond_to?(:value) && node.first_argument.value
-            node.parent.each_child_node(:def).find do |child|
-              child.method?(method_name)
+            method_names = node.arguments.filter_map do |argument|
+              next unless argument.sym_type?
+
+              argument.respond_to?(:value) && argument.value
             end
+
+            def_nodes = node.parent.each_child_node(:def).select do |child|
+              method_names.include?(child.method_name)
+            end
+
+            # If there isn't a `def` node for each symbol, we will skip autocorrection.
+            def_nodes.size == method_names.size ? def_nodes : []
           else
-            node.first_argument
+            [node.first_argument]
           end
         end
 
@@ -251,12 +305,12 @@ module RuboCop
           end.select(&:def_type?)
         end
 
-        def replace_def(corrector, node, def_node)
-          source = def_source(node, def_node)
+        def replace_defs(corrector, node, def_nodes)
+          source = def_source(node, def_nodes)
           argument_less_modifier_node = find_argument_less_modifier_node(node)
           if argument_less_modifier_node
             corrector.insert_after(argument_less_modifier_node, "\n\n#{source}")
-          elsif (ancestor = node.each_ancestor(:block, :class, :module).first)
+          elsif (ancestor = node.each_ancestor(:class, :module).first)
 
             corrector.insert_before(ancestor.loc.end, "#{node.method_name}\n\n#{source}\n")
           else
@@ -264,20 +318,24 @@ module RuboCop
             return
           end
 
-          remove_node(corrector, def_node)
-          remove_node(corrector, node)
+          remove_nodes(corrector, *def_nodes, node)
         end
 
         def insert_inline_modifier(corrector, node, modifier_name)
           corrector.insert_before(node, "#{modifier_name} ")
         end
 
-        def remove_node(corrector, node)
-          corrector.remove(range_with_comments_and_lines(node))
+        def remove_nodes(corrector, *nodes)
+          nodes.each do |node|
+            corrector.remove(range_with_comments_and_lines(node))
+          end
         end
 
-        def def_source(node, def_node)
-          [*processed_source.ast_with_comments[node].map(&:text), def_node.source].join("\n")
+        def def_source(node, def_nodes)
+          [
+            *processed_source.ast_with_comments[node].map(&:text),
+            *def_nodes.map(&:source)
+          ].join("\n")
         end
       end
     end

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

@@ -139,12 +139,16 @@ module RuboCop
           style == :separated
         end
 
+        def groupable_sibling_accessor?(node, sibling)
+          sibling.attribute_accessor? &&
+            sibling.method?(node.method_name) &&
+            node_visibility(sibling) == node_visibility(node) &&
+            groupable_accessor?(sibling) && !previous_line_comment?(sibling)
+        end
+
         def groupable_sibling_accessors(send_node)
           send_node.parent.each_child_node(:send).select do |sibling|
-            sibling.attribute_accessor? &&
-              sibling.method?(send_node.method_name) &&
-              node_visibility(sibling) == node_visibility(send_node) &&
-              groupable_accessor?(sibling) && !previous_line_comment?(sibling)
+            groupable_sibling_accessor?(send_node, sibling)
           end
         end
 
@@ -155,13 +159,23 @@ module RuboCop
 
         def preferred_accessors(node)
           if grouped_style?
+            return if skip_for_grouping?(node)
+
             accessors = groupable_sibling_accessors(node)
-            group_accessors(node, accessors) if node.loc == accessors.first.loc
+            if node.loc == accessors.first.loc || skip_for_grouping?(accessors.first)
+              group_accessors(node, accessors)
+            end
           else
             separate_accessors(node)
           end
         end
 
+        # Group after constants
+        def skip_for_grouping?(node)
+          node.right_siblings.any?(&:casgn_type?) &&
+            node.right_siblings.any? { |n| n.send_type? && groupable_sibling_accessor?(node, n) }
+        end
+
         def group_accessors(node, accessors)
           accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }.uniq
 

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for endless methods inside operations of lower precedence (`and`, `or`, and
+      # modifier forms of `if`, `unless`, `while`, `until`) that are ambiguous due to
+      # lack of parentheses. This may lead to unexpected behavior as the code may appear
+      # to use these keywords as part of the method but in fact they modify
+      # the method definition itself.
+      #
+      # In these cases, using a normal method definition is more clear.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo = true if bar
+      #
+      #   # good - using a non-endless method is more explicit
+      #   def foo
+      #     true
+      #   end if bar
+      #
+      #   # ok - method body is explicit
+      #   def foo = (true if bar)
+      #
+      #   # ok - method definition is explicit
+      #   (def foo = true) if bar
+      class AmbiguousEndlessMethodDefinition < Base
+        extend TargetRubyVersion
+        extend AutoCorrector
+        include EndlessMethodRewriter
+        include RangeHelp
+
+        minimum_target_ruby_version 3.0
+
+        MSG = 'Avoid using `%<keyword>s` statements with endless methods.'
+
+        # @!method ambiguous_endless_method_body(node)
+        def_node_matcher :ambiguous_endless_method_body, <<~PATTERN
+          ^${
+            (if _ <def _>)
+            ({and or} def _)
+            ({while until} _ def)
+          }
+        PATTERN
+
+        def on_def(node)
+          return unless node.endless?
+
+          operation = ambiguous_endless_method_body(node)
+          return unless operation
+
+          return unless modifier_form?(operation)
+
+          add_offense(operation, message: format(MSG, keyword: keyword(operation))) do |corrector|
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        private
+
+        def modifier_form?(operation)
+          return true if operation.operator_keyword?
+
+          operation.modifier_form?
+        end
+
+        def keyword(operation)
+          if operation.respond_to?(:keyword)
+            operation.keyword
+          else
+            operation.operator
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -127,7 +127,7 @@ module RuboCop
         end
 
         def correct_other(node, corrector)
-          return if node.source_range.begin.is?('(')
+          return if node.parenthesized_call?
 
           corrector.wrap(node, '(', ')')
         end

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

@@ -31,6 +31,20 @@ module RuboCop
       #
       # This cop handles not only method forwarding but also forwarding to `super`.
       #
+      # [NOTE]
+      # ====
+      # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
+      # no offense will be registered until Ruby 3.4:
+      #
+      # [source,ruby]
+      # ----
+      # def foo(&block)
+      #   # Using an anonymous block would be a syntax error on Ruby 3.3.0
+      #   block_method { bar(&block) }
+      # end
+      # ----
+      # ====
+      #
       # @example
       #   # bad
       #   def foo(*args, &block)
@@ -148,7 +162,7 @@ module RuboCop
 
           restarg, kwrestarg, blockarg = extract_forwardable_args(node.arguments)
           forwardable_args = redundant_forwardable_named_args(restarg, kwrestarg, blockarg)
-          send_nodes = node.each_descendant(:send, :csend, :super, :yield).to_a
+          send_nodes = node.each_descendant(:call, :super, :yield).to_a
 
           send_classifications = classify_send_nodes(
             node, send_nodes, non_splat_or_block_pass_lvar_references(node.body), forwardable_args
@@ -191,9 +205,7 @@ module RuboCop
 
           send_classifications.each do |send_node, c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
             if !forward_rest && !forward_kwrest && c != :all_anonymous
-              # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
-              # in Ruby 3.3.0.
-              if outside_block?(forward_block_arg)
+              if allow_anonymous_forwarding_in_block?(forward_block_arg)
                 register_forward_block_arg_offense(!forward_rest, node.arguments, block_arg)
                 register_forward_block_arg_offense(!forward_rest, send_node, forward_block_arg)
               end
@@ -214,24 +226,22 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
           return unless use_anonymous_forwarding?
-          return if send_inside_block?(send_classifications)
+          return unless all_forwarding_offenses_correctable?(send_classifications)
 
           rest_arg, kwrest_arg, block_arg = *forwardable_args
 
           send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
-            if outside_block?(forward_rest)
+            if allow_anonymous_forwarding_in_block?(forward_rest)
               register_forward_args_offense(def_node.arguments, rest_arg)
               register_forward_args_offense(send_node, forward_rest)
             end
 
-            if outside_block?(forward_kwrest)
+            if allow_anonymous_forwarding_in_block?(forward_kwrest)
               register_forward_kwargs_offense(!forward_rest, def_node.arguments, kwrest_arg)
               register_forward_kwargs_offense(!forward_rest, send_node, forward_kwrest)
             end
 
-            # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
-            # in Ruby 3.3.0.
-            if outside_block?(forward_block_arg)
+            if allow_anonymous_forwarding_in_block?(forward_block_arg)
               register_forward_block_arg_offense(!forward_rest, def_node.arguments, block_arg)
               register_forward_block_arg_offense(!forward_rest, send_node, forward_block_arg)
             end
@@ -293,10 +303,25 @@ module RuboCop
           redundant_arg_names.include?(arg.source) ? arg : nil
         end
 
-        def outside_block?(node)
+        # Checks if forwarding is uses both in blocks and outside of blocks.
+        # On Ruby 3.3.0, anonymous block forwarding in blocks can be is a syntax
+        # error, so we only want to register an offense if we can change all occurrences.
+        def all_forwarding_offenses_correctable?(send_classifications)
+          return true if target_ruby_version >= 3.4
+
+          send_classifications.none? do |send_node, *|
+            send_node.each_ancestor(:any_block).any?
+          end
+        end
+
+        # Ruby 3.3.0 had a bug where accessing an anonymous block argument inside of a block
+        # was a syntax error in unambiguous cases: https://bugs.ruby-lang.org/issues/20090
+        # We disallow this also for earlier Ruby versions so that code is forwards compatible.
+        def allow_anonymous_forwarding_in_block?(node)
           return false unless node
+          return true if target_ruby_version >= 3.4
 
-          node.each_ancestor(:block, :numblock).none?
+          node.each_ancestor(:any_block).none?
         end
 
         def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat)
@@ -357,12 +382,6 @@ module RuboCop
           cop_config.fetch('UseAnonymousForwarding', false)
         end
 
-        def send_inside_block?(send_classifications)
-          send_classifications.any? do |send_node, *|
-            send_node.each_ancestor(:block, :numblock).any?
-          end
-        end
-
         def add_parens_if_missing(node, corrector)
           return if parentheses?(node)
           return if node.send_type? && node.method?(:[])
@@ -511,7 +530,7 @@ module RuboCop
           end
 
           def additional_kwargs?
-            @def_node.arguments.any? { |a| a.kwarg_type? || a.kwoptarg_type? }
+            @def_node.arguments.any? { |a| a.type?(:kwarg, :kwoptarg) }
           end
 
           def forward_additional_kwargs?
@@ -540,10 +559,7 @@ module RuboCop
         end
 
         def explicit_block_name?
-          block_forwarding_config = config.for_cop('Naming/BlockForwarding')
-          return false unless block_forwarding_config['Enabled']
-
-          block_forwarding_config['EnforcedStyle'] == 'explicit'
+          config.for_enabled_cop('Naming/BlockForwarding')['EnforcedStyle'] == 'explicit'
         end
       end
     end

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

@@ -42,14 +42,30 @@ module RuboCop
           return if node.parent && brace_method?(node.parent)
 
           preferred = (value.zero? ? 'first' : 'last')
-          add_offense(node.loc.selector, message: format(MSG, preferred: preferred)) do |corrector|
-            corrector.replace(node.loc.selector, ".#{preferred}")
+          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
         # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
 
         private
 
+        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

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

@@ -28,6 +28,7 @@ module RuboCop
       #   # bad
       #   (array1 & array2).any?
       #   (array1 & array2).empty?
+      #   (array1 & array2).none?
       #
       #   # good
       #   array1.intersect?(array2)
@@ -57,7 +58,7 @@ module RuboCop
           (send
             (begin
               (send $(...) :& $(...))
-            ) ${:any? :empty?}
+            ) ${:any? :empty? :none?}
           )
         PATTERN
 
@@ -66,18 +67,18 @@ module RuboCop
           (send
             (begin
               (send $(...) :& $(...))
-            ) ${:present? :any? :blank? :empty?}
+            ) ${:present? :any? :blank? :empty? :none?}
           )
         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
+        NEGATED_METHODS = %i[blank? empty? none?].freeze
         RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
 
         def on_send(node)
-          return if (parent = node.parent) && (parent.block_type? || parent.numblock_type?)
+          return if node.block_literal?
           return unless (receiver, argument, method_name = bad_intersection_check?(node))
 
           message = message(receiver.source, argument.source, method_name)

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