rubocop 1.31.1 → 1.52.1

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

@@ -9,6 +9,11 @@ module RuboCop
       # Applications of visibility methods to symbols can be controlled
       # using AllowModifiersOnSymbols config.
       #
+      # @safety
+      #   Autocorrection is not safe, because the visibility of dynamically
+      #   defined methods can vary depending on the state determined by
+      #   the group access modifier.
+      #
       # @example EnforcedStyle: group (default)
       #   # bad
       #   class Foo
@@ -63,7 +68,10 @@ module RuboCop
       #
       #   end
       class AccessModifierDeclarations < Base
+        extend AutoCorrector
+
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         GROUP_STYLE_MESSAGE = [
           '`%<access_modifier>s` should not be',
@@ -77,6 +85,8 @@ 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 _))
@@ -84,11 +94,14 @@ module RuboCop
 
         def on_send(node)
           return unless node.access_modifier?
-          return if node.parent&.pair_type?
+          return if ALLOWED_NODE_TYPES.include?(node.parent&.type)
           return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)
-            add_offense(node.loc.selector) { opposite_style_detected }
+            add_offense(node.loc.selector) do |corrector|
+              autocorrect(corrector, node)
+            end
+            opposite_style_detected
           else
             correct_style_detected
           end
@@ -96,12 +109,28 @@ module RuboCop
 
         private
 
+        def autocorrect(corrector, node)
+          case style
+          when :group
+            def_node = find_corresponding_def_node(node)
+            return unless def_node
+
+            replace_def(corrector, node, def_node)
+          when :inline
+            remove_node(corrector, node)
+            select_grouped_def_nodes(node).each do |grouped_def_node|
+              insert_inline_modifier(corrector, grouped_def_node, node.method_name)
+            end
+          end
+        end
+
         def allow_modifiers_on_symbols?(node)
           cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
         end
 
         def offense?(node)
-          (group_style? && access_modifier_is_inlined?(node)) ||
+          (group_style? && access_modifier_is_inlined?(node) &&
+            !right_siblings_same_inline_method?(node)) ||
             (inline_style? && access_modifier_is_not_inlined?(node))
         end
 
@@ -121,6 +150,12 @@ module RuboCop
           !access_modifier_is_inlined?(node)
         end
 
+        def right_siblings_same_inline_method?(node)
+          node.right_siblings.any? do |sibling|
+            sibling.send_type? && sibling.method?(node.method_name) && !sibling.arguments.empty?
+          end
+        end
+
         def message(range)
           access_modifier = range.source
 
@@ -130,6 +165,60 @@ module RuboCop
             format(INLINE_STYLE_MESSAGE, access_modifier: access_modifier)
           end
         end
+
+        def find_corresponding_def_node(node)
+          if access_modifier_with_symbol?(node)
+            method_name = node.arguments.first.value
+            node.parent.each_child_node(:def).find do |child|
+              child.method?(method_name)
+            end
+          else
+            node.arguments.first
+          end
+        end
+
+        def find_argument_less_modifier_node(node)
+          return unless (parent = node.parent)
+
+          parent.each_child_node(:send).find do |child|
+            child.method?(node.method_name) && child.arguments.empty?
+          end
+        end
+
+        def select_grouped_def_nodes(node)
+          node.right_siblings.take_while do |sibling|
+            !(sibling.send_type? && sibling.bare_access_modifier_declaration?)
+          end.select(&:def_type?)
+        end
+
+        def replace_def(corrector, node, def_node)
+          source = def_source(node, def_node)
+          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)
+
+            corrector.insert_before(ancestor.loc.end, "#{node.method_name}\n\n#{source}\n")
+          else
+            corrector.replace(node, "#{node.method_name}\n\n#{source}")
+            return
+          end
+
+          remove_node(corrector, def_node)
+          remove_node(corrector, 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))
+        end
+
+        def def_source(node, def_node)
+          [*processed_source.ast_with_comments[node].map(&:text), def_node.source].join("\n")
+        end
       end
     end
   end

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

@@ -7,19 +7,32 @@ module RuboCop
       # By default it enforces accessors to be placed in grouped declarations,
       # but it can be configured to enforce separating them in multiple declarations.
       #
-      # NOTE: `Sorbet` is not compatible with "grouped" style. Consider "separated" style
-      # or disabling this cop.
+      # NOTE: If there is a method call before the accessor method it is always allowed
+      # as it might be intended like Sorbet.
       #
       # @example EnforcedStyle: grouped (default)
       #   # bad
       #   class Foo
       #     attr_reader :bar
+      #     attr_reader :bax
       #     attr_reader :baz
       #   end
       #
       #   # good
       #   class Foo
-      #     attr_reader :bar, :baz
+      #     attr_reader :bar, :bax, :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     # may be intended comment for bar.
+      #     attr_reader :bar
+      #
+      #     sig { returns(String) }
+      #     attr_reader :bax
+      #
+      #     may_be_intended_annotation :baz
+      #     attr_reader :baz
       #   end
       #
       # @example EnforcedStyle: separated
@@ -43,11 +56,9 @@ module RuboCop
         GROUPED_MSG = 'Group together all `%<accessor>s` attributes.'
         SEPARATED_MSG = 'Use one attribute per `%<accessor>s`.'
 
-        ACCESSOR_METHODS = %i[attr_reader attr_writer attr_accessor attr].freeze
-
         def on_class(node)
           class_send_elements(node).each do |macro|
-            next unless accessor?(macro)
+            next unless macro.attribute_accessor?
 
             check(macro)
           end
@@ -58,8 +69,8 @@ module RuboCop
         private
 
         def check(send_node)
-          return if previous_line_comment?(send_node)
-          return unless (grouped_style? && sibling_accessors(send_node).size > 1) ||
+          return if previous_line_comment?(send_node) || !groupable_accessor?(send_node)
+          return unless (grouped_style? && groupable_sibling_accessors(send_node).size > 1) ||
                         (separated_style? && send_node.arguments.size > 1)
 
           message = message(send_node)
@@ -72,7 +83,7 @@ module RuboCop
           if (preferred_accessors = preferred_accessors(node))
             corrector.replace(node, preferred_accessors)
           else
-            range = range_with_surrounding_space(node.loc.expression, side: :left)
+            range = range_with_surrounding_space(node.source_range, side: :left)
             corrector.remove(range)
           end
         end
@@ -81,6 +92,25 @@ module RuboCop
           comment_line?(processed_source[node.first_line - 2])
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def groupable_accessor?(node)
+          return true unless (previous_expression = node.left_siblings.last)
+
+          # Accessors with Sorbet `sig { ... }` blocks shouldn't be groupable.
+          if previous_expression.block_type?
+            previous_expression.child_nodes.each do |child_node|
+              break previous_expression = child_node if child_node.send_type?
+            end
+          end
+
+          return true unless previous_expression.send_type?
+
+          previous_expression.attribute_accessor? ||
+            previous_expression.access_modifier? ||
+            node.first_line - previous_expression.last_line > 1 # there is a space between nodes
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
         def class_send_elements(class_node)
           class_def = class_node.body
 
@@ -93,10 +123,6 @@ module RuboCop
           end
         end
 
-        def accessor?(send_node)
-          send_node.macro? && ACCESSOR_METHODS.include?(send_node.method_name)
-        end
-
         def grouped_style?
           style == :grouped
         end
@@ -105,12 +131,12 @@ module RuboCop
           style == :separated
         end
 
-        def sibling_accessors(send_node)
+        def groupable_sibling_accessors(send_node)
           send_node.parent.each_child_node(:send).select do |sibling|
-            accessor?(sibling) &&
+            sibling.attribute_accessor? &&
               sibling.method?(send_node.method_name) &&
               node_visibility(sibling) == node_visibility(send_node) &&
-              !previous_line_comment?(sibling)
+              groupable_accessor?(sibling) && !previous_line_comment?(sibling)
           end
         end
 
@@ -121,7 +147,7 @@ module RuboCop
 
         def preferred_accessors(node)
           if grouped_style?
-            accessors = sibling_accessors(node)
+            accessors = groupable_sibling_accessors(node)
             group_accessors(node, accessors) if node.loc == accessors.first.loc
           else
             separate_accessors(node)
@@ -135,12 +161,16 @@ module RuboCop
         end
 
         def separate_accessors(node)
-          node.arguments.map do |arg|
-            if arg == node.arguments.first
+          node.arguments.flat_map do |arg|
+            lines = [
+              *processed_source.ast_with_comments[arg].map(&:text),
               "#{node.method_name} #{arg.source}"
+            ]
+            if arg == node.arguments.first
+              lines
             else
               indent = ' ' * node.loc.column
-              "#{indent}#{node.method_name} #{arg.source}"
+              lines.map { |line| "#{indent}#{line}" }
             end
           end.join("\n")
         end

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

@@ -7,6 +7,11 @@ module RuboCop
       # depending on configuration.
       # It also flags uses of `alias :symbol` rather than `alias bareword`.
       #
+      # However, it will always enforce `method_alias` when used `alias`
+      # in an instance method definition and in a singleton method definition.
+      # If used in a block, always enforce `alias_method`
+      # unless it is an `instance_eval` block.
+      #
       # @example EnforcedStyle: prefer_alias (default)
       #   # bad
       #   alias_method :bar, :foo
@@ -22,6 +27,7 @@ module RuboCop
       #
       #   # good
       #   alias_method :bar, :foo
+      #
       class Alias < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -71,7 +77,9 @@ module RuboCop
         end
 
         def alias_method_possible?(node)
-          scope_type(node) != :instance_eval && node.children.none?(&:gvar_type?)
+          scope_type(node) != :instance_eval &&
+            node.children.none?(&:gvar_type?) &&
+            node&.parent&.type != :def
         end
 
         def add_offense_for_args(node, &block)

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

@@ -73,17 +73,18 @@ module RuboCop
           {
             (send _ _
               (splat (lvar %1))
-              (block-pass (lvar %2)))
+              (block-pass {(lvar %2) nil?}))
             (send _ _
               (splat (lvar %1))
               (hash (kwsplat (lvar %3)))
-              (block-pass (lvar %2)))
+              (block-pass {(lvar %2) nil?}))
           }
         PATTERN
 
         def on_def(node)
           return unless node.body
           return unless (rest_args_name, args = use_rest_arguments?(node.arguments))
+          return if args.any?(&:default?)
 
           node.each_descendant(:send) do |send_node|
             kwargs_name, block_name = extract_argument_names_from(args)
@@ -123,9 +124,9 @@ module RuboCop
 
         def register_offense_to_forwarding_method_arguments(forwarding_method)
           add_offense(arguments_range(forwarding_method)) do |corrector|
-            range = range_between(
-              forwarding_method.loc.selector.end_pos, forwarding_method.source_range.end_pos
-            )
+            begin_pos = forwarding_method.loc.selector&.end_pos || forwarding_method.loc.dot.end_pos
+            range = range_between(begin_pos, forwarding_method.source_range.end_pos)
+
             corrector.replace(range, '(...)')
           end
         end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    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)`.
+      #
+      # The `array1.intersect?(array2)` method is faster than
+      # `(array1 & array2).any?` and is more readable.
+      #
+      # @safety
+      #   This cop cannot guarantee that `array1` and `array2` are
+      #   actually arrays while method `intersect?` is for arrays only.
+      #
+      # @example
+      #   # bad
+      #   (array1 & array2).any?
+      #   (array1 & array2).empty?
+      #
+      #   # good
+      #   array1.intersect?(array2)
+      #   !array1.intersect?(array2)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #   # good
+      #   (array1 & array2).present?
+      #   (array1 & array2).blank?
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #   # bad
+      #   (array1 & array2).present?
+      #   (array1 & array2).blank?
+      #
+      #   # good
+      #   array1.intersect?(array2)
+      #   !array1.intersect?(array2)
+      class ArrayIntersect < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        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?}
+          )
+        PATTERN
+
+        # @!method active_support_bad_intersection_check?(node)
+        def_node_matcher :active_support_bad_intersection_check?, <<~PATTERN
+          (send
+            (begin
+              (send $(...) :& $(...))
+            ) ${:present? :any? :blank? :empty?}
+          )
+        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
+        RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
+
+        def on_send(node)
+          return unless (receiver, argument, method_name = bad_intersection_check?(node))
+
+          message = message(receiver.source, argument.source, method_name)
+
+          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
+        end
+
+        private
+
+        def bad_intersection_check?(node)
+          if active_support_extensions_enabled?
+            active_support_bad_intersection_check?(node)
+          else
+            regular_bad_intersection_check?(node)
+          end
+        end
+
+        def straight?(method_name)
+          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
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -30,7 +30,7 @@ module RuboCop
         private
 
         def first_offense_range(comment)
-          expression    = comment.loc.expression
+          expression    = comment.source_range
           first_offense = first_non_ascii_chars(comment.text)
 
           start_position = expression.begin_pos + comment.text.index(first_offense)

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

@@ -55,7 +55,7 @@ module RuboCop
         def after_class(class_node)
           @macros_to_rewrite[class_node].each do |macro|
             node = macro.node
-            range = range_by_whole_lines(node.loc.expression, include_final_newline: true)
+            range = range_by_whole_lines(node.source_range, include_final_newline: true)
 
             correct(range) do |corrector|
               if macro.writer?

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

@@ -32,7 +32,7 @@ module RuboCop
               eq_begin, eq_end, contents = parts(comment)
 
               corrector.remove(eq_begin)
-              unless contents.length.zero?
+              unless contents.empty?
                 corrector.replace(
                   contents,
                   contents.source.gsub(/\A/, '# ').gsub(/\n\n/, "\n#\n").gsub(/\n(?=[^#])/, "\n# ")
@@ -46,7 +46,7 @@ module RuboCop
         private
 
         def parts(comment)
-          expr = comment.loc.expression
+          expr = comment.source_range
           eq_begin = expr.resize(BEGIN_LENGTH)
           eq_end = eq_end_part(comment, expr)
           contents = range_between(eq_begin.end_pos, eq_end.begin_pos)

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

@@ -10,7 +10,7 @@ module RuboCop
       # Methods that can be either procedural or functional and cannot be
       # categorised from their usage alone is ignored.
       # `lambda`, `proc`, and `it` are their defaults.
-      # Additional methods can be added to the `IgnoredMethods`.
+      # Additional methods can be added to the `AllowedMethods`.
       #
       # @example EnforcedStyle: line_count_based (default)
       #   # bad - single line block
@@ -66,7 +66,7 @@ module RuboCop
       #     x
       #   }.inspect
       #
-      #   # The AllowBracesOnProceduralOneLiners option is ignored unless the
+      #   # The AllowBracesOnProceduralOneLiners option is allowed unless the
       #   # EnforcedStyle is set to `semantic`. If so:
       #
       #   # If the AllowBracesOnProceduralOneLiners option is unspecified, or
@@ -116,7 +116,7 @@ module RuboCop
       #
       #   # Methods listed in the BracesRequiredMethods list, such as 'sig'
       #   # in this example, will require `{...}` braces. This option takes
-      #   # precedence over all other configurations except IgnoredMethods.
+      #   # precedence over all other configurations except AllowedMethods.
       #
       #   # bad
       #   sig do
@@ -138,7 +138,7 @@ module RuboCop
       #     puts foo
       #   end
       #
-      # @example IgnoredMethods: ['lambda', 'proc', 'it' ] (default)
+      # @example AllowedMethods: ['lambda', 'proc', 'it' ] (default)
       #
       #   # good
       #   foo = lambda do |x|
@@ -149,9 +149,26 @@ module RuboCop
       #     x * 100
       #   end
       #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   things.map { |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   }
+      #
+      # @example AllowedPatterns: ['map']
+      #
+      #   # good
+      #   things.map { |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   }
+      #
       class BlockDelimiters < Base
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         include RangeHelp
         extend AutoCorrector
 
@@ -282,8 +299,8 @@ 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
-          comment_range = range_between(range.end_pos, comment.loc.expression.end_pos)
-          corrector.remove(range_with_surrounding_space(comment_range, side: :right))
+          corrector.remove(range_with_surrounding_space(comment.source_range, side: :right))
+          remove_trailing_whitespace(corrector, range, comment)
           corrector.insert_after(range, "\n")
 
           corrector.insert_before(block_node, "#{comment.text}\n")
@@ -296,6 +313,12 @@ module RuboCop
           end_of_chain(node.parent)
         end
 
+        def remove_trailing_whitespace(corrector, range, comment)
+          range_of_trailing = range.end.join(comment.source_range.begin)
+
+          corrector.remove(range_of_trailing) if range_of_trailing.source.match?(/\A\s+\z/)
+        end
+
         def with_block?(node)
           node.respond_to?(:block_node) && node.block_node
         end
@@ -319,6 +342,7 @@ module RuboCop
         end
 
         def proper_block_style?(node)
+          return true if require_braces?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)
 
           case style
@@ -329,13 +353,23 @@ module RuboCop
           end
         end
 
+        def require_braces?(node)
+          return false unless node.braces?
+
+          node.each_ancestor(:send).any? do |send|
+            send.arithmetic_operation? && node.source_range.end_pos < send.loc.selector.begin_pos
+          end
+        end
+
         def special_method?(method_name)
-          ignored_method?(method_name) || braces_required_method?(method_name)
+          allowed_method?(method_name) ||
+            matches_allowed_pattern?(method_name) ||
+            braces_required_method?(method_name)
         end
 
         def special_method_proper_block_style?(node)
           method_name = node.method_name
-          return true if ignored_method?(method_name)
+          return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
           return node.braces? if braces_required_method?(method_name)
         end
 
@@ -406,7 +440,7 @@ module RuboCop
           if node.parent.begin_type?
             return_value_used?(node.parent)
           else
-            node.parent.assignment? || node.parent.send_type?
+            node.parent.assignment? || node.parent.call_type?
           end
         end