rubocop 1.75.1 → 1.76.0

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -242,7 +242,7 @@ module RuboCop
         def find_definition(node)
           # Methods can be defined in a `def` or `defs`,
           # or dynamically via a `block` node.
-          node.each_ancestor(:def, :defs, :block).each do |ancestor|
+          node.each_ancestor(:any_def, :block).each do |ancestor|
             method_node, method_name = method_definition?(ancestor)
             return [method_node, method_name] if method_node
           end

data/lib/rubocop/cop/naming/method_name.rb

@@ -105,7 +105,7 @@ module RuboCop
         end
 
         def register_forbidden_name(node)
-          if node.type?(:def, :defs)
+          if node.any_def_type?
             name_node = node.loc.name
             method_name = node.method_name
           else

data/lib/rubocop/cop/naming/predicate_method.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # Checks that predicate methods end with `?` and non-predicate methods do not.
+      #
+      # The names of predicate methods (methods that return a boolean value) should end
+      # in a question mark. Methods that don’t return a boolean, shouldn’t
+      # end in a question mark.
+      #
+      # The cop assesses a predicate method as one that returns boolean values. Likewise,
+      # a method that only returns literal values is assessed as non-predicate. The cop does
+      # not make an assessment if the return type is unknown (method calls, variables, etc.).
+      #
+      # NOTE: Operator methods (`def ==`, etc.) are ignored.
+      #
+      # By default, the cop runs in `conservative` mode, which allows a method to be named
+      # with a question mark as long as at least one return value is boolean. In `aggressive`
+      # mode, methods with a question mark will register an offense if any known non-boolean
+      # return values are detected.
+      #
+      # The cop also has `AllowedMethods` configuration in order to prevent the cop from
+      # registering an offense from a method name that does not confirm to the naming
+      # guidelines. By default, `call` is allowed.
+      #
+      # @example Mode: conservative (default)
+      #   # bad
+      #   def foo
+      #     bar == baz
+      #   end
+      #
+      #   # good
+      #   def foo?
+      #     bar == baz
+      #   end
+      #
+      #   # bad
+      #   def foo?
+      #     5
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     5
+      #   end
+      #
+      #   # good - operator method
+      #   def ==(other)
+      #     hash == other.hash
+      #   end
+      #
+      #   # good - at least one return value is boolean
+      #   def foo?
+      #     return unless bar?
+      #     true
+      #   end
+      #
+      #   # ok - return type is not known
+      #   def foo?
+      #     bar
+      #   end
+      #
+      #   # ok - return type is not known
+      #   def foo
+      #     bar?
+      #   end
+      #
+      # @example Mode: aggressive
+      #   # bad - the method returns nil in some cases
+      #   def foo?
+      #     return unless bar?
+      #     true
+      #   end
+      #
+      class PredicateMethod < Base
+        include AllowedMethods
+
+        MSG_PREDICATE = 'Predicate method names should end with `?`.'
+        MSG_NON_PREDICATE = 'Non-predicate method names should not end with `?`.'
+
+        def on_def(node)
+          return if allowed?(node)
+
+          return_values = return_values(node.body)
+          return if acceptable?(return_values)
+
+          if node.predicate_method? && potential_non_predicate?(return_values)
+            add_offense(node.loc.name, message: MSG_NON_PREDICATE)
+          elsif !node.predicate_method? && all_return_values_boolean?(return_values)
+            add_offense(node.loc.name, message: MSG_PREDICATE)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def allowed?(node)
+          allowed_method?(node.method_name) ||
+            node.operator_method? ||
+            node.body.nil?
+        end
+
+        def acceptable?(return_values)
+          # In `conservative` mode, if the method returns `super`, `zsuper`, or a
+          # non-comparison method call, the method name is acceptable.
+          return false unless conservative?
+
+          return_values.any? do |value|
+            value.type?(:super, :zsuper) || non_comparison_call?(value)
+          end
+        end
+
+        def non_comparison_call?(value)
+          value.call_type? && !value.comparison_method?
+        end
+
+        def return_values(node)
+          # Collect all the (implicit and explicit) return values of a node
+          return_values = Set.new(node.begin_type? ? [] : [extract_return_value(node)])
+
+          node.each_descendant(:return) do |return_node|
+            return_values << extract_return_value(return_node)
+          end
+
+          last_value = last_value(node)
+          return_values << last_value if last_value
+
+          process_return_values(return_values)
+        end
+
+        def all_return_values_boolean?(return_values)
+          values = return_values.reject { |value| value.type?(:super, :zsuper) }
+          return false if values.empty?
+
+          values.all? { |value| boolean_return?(value) }
+        end
+
+        def boolean_return?(value)
+          value.boolean_type? || (value.call_type? && value.comparison_method?)
+        end
+
+        def potential_non_predicate?(return_values)
+          # Assumes a method to be non-predicate if all return values are non-boolean literals.
+          #
+          # In `Mode: conservative`, if any of the return values is a boolean,
+          # the method name is acceptable.
+          # In `Mode: aggressive`, all return values must be booleans for a predicate
+          # method, or else an offense will be registered.
+          return false if conservative? && return_values.any? { |value| boolean_return?(value) }
+
+          return_values.any? do |value|
+            value.literal? && !value.boolean_type?
+          end
+        end
+
+        def extract_return_value(node)
+          return node unless node.return_type?
+
+          # `return` without a value is a `nil` return.
+          return s(:nil) if node.arguments.empty?
+
+          # When there's a multiple return, it cannot be a predicate
+          # so just return an `array` sexp for simplicity.
+          return s(:array) unless node.arguments.one?
+
+          node.first_argument
+        end
+
+        def last_value(node)
+          value = node.begin_type? ? node.children.last : node
+          value.return_type? ? extract_return_value(value) : value
+        end
+
+        def process_return_values(return_values)
+          return_values.flat_map do |value|
+            if value.conditional?
+              process_return_values(extract_conditional_branches(value))
+            elsif and_or?(value)
+              process_return_values(extract_and_or_clauses(value))
+            else
+              value
+            end
+          end
+        end
+
+        def and_or?(node)
+          node.type?(:and, :or)
+        end
+
+        def extract_and_or_clauses(node)
+          # Recursively traverse an `and` or `or` node to collect all clauses within
+          return node unless and_or?(node)
+
+          [extract_and_or_clauses(node.lhs), extract_and_or_clauses(node.rhs)].flatten
+        end
+
+        def extract_conditional_branches(node)
+          return node unless node.conditional?
+
+          if node.type?(:while, :until)
+            # If there is no body, act as implicit `nil`.
+            node.body ? [last_value(node.body)] : [s(:nil)]
+          else
+            # Branches with no value act as an implicit `nil`.
+            node.branches.filter_map { |branch| branch ? last_value(branch) : s(:nil) }
+          end
+        end
+
+        def conservative?
+          cop_config.fetch('Mode', :conservative).to_sym == :conservative
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/{predicate_name.rb → predicate_prefix.rb}

@@ -100,7 +100,7 @@ module RuboCop
       #   # good
       #   def_node_matcher(:even?) { |value| }
       #
-      class PredicateName < Base
+      class PredicatePrefix < Base
         include AllowedMethods
 
         # @!method dynamic_method_define(node)
@@ -143,7 +143,7 @@ module RuboCop
             next if predicate_prefixes.include?(forbidden_prefix)
 
             raise ValidationError, <<~MSG.chomp
-              The `Naming/PredicateName` cop is misconfigured. Prefix #{forbidden_prefix} must be included in NamePrefix because it is included in ForbiddenPrefixes.
+              The `Naming/PredicatePrefix` cop is misconfigured. Prefix #{forbidden_prefix} must be included in NamePrefix because it is included in ForbiddenPrefixes.
             MSG
           end
         end

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

@@ -195,15 +195,27 @@ module RuboCop
         def autocorrect(corrector, node)
           case style
           when :group
-            def_nodes = find_corresponding_def_nodes(node)
-            return unless def_nodes.any?
-
-            replace_defs(corrector, node, def_nodes)
+            autocorrect_group_style(corrector, node)
           when :inline
+            autocorrect_inline_style(corrector, node)
+          end
+        end
+
+        def autocorrect_group_style(corrector, node)
+          def_nodes = find_corresponding_def_nodes(node)
+          return unless def_nodes.any?
+
+          replace_defs(corrector, node, def_nodes)
+        end
+
+        def autocorrect_inline_style(corrector, node)
+          if node.parent&.begin_type?
+            remove_modifier_node_within_begin(corrector, node, node.parent)
+          else
             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
+          end
+          select_grouped_def_nodes(node).each do |grouped_def_node|
+            insert_inline_modifier(corrector, grouped_def_node, node.method_name)
           end
         end
 
@@ -224,9 +236,13 @@ module RuboCop
         end
 
         def offense?(node)
-          (group_style? && access_modifier_is_inlined?(node) &&
-            !node.parent&.if_type? && !right_siblings_same_inline_method?(node)) ||
-            (inline_style? && access_modifier_is_not_inlined?(node))
+          if group_style?
+            return false if node.parent ? node.parent.if_type? : access_modifier_with_symbol?(node)
+
+            access_modifier_is_inlined?(node) && !right_siblings_same_inline_method?(node)
+          else
+            access_modifier_is_not_inlined?(node) && select_grouped_def_nodes(node).any?
+          end
         end
 
         def correctable_group_offense?(node)
@@ -331,6 +347,12 @@ module RuboCop
           end
         end
 
+        def remove_modifier_node_within_begin(corrector, modifier_node, begin_node)
+          def_node = begin_node.children[1]
+          range = modifier_node.source_range.begin.join(def_node.source_range.begin)
+          corrector.remove(range)
+        end
+
         def def_source(node, def_nodes)
           [
             *processed_source.ast_with_comments[node].map(&:text),

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

@@ -16,16 +16,16 @@ module RuboCop
       #
       # In Ruby 3.2, anonymous args/kwargs forwarding has been added.
       #
-      # This cop also identifies places where `use_args(*args)`/`use_kwargs(**kwargs)` can be
-      # replaced by `use_args(*)`/`use_kwargs(**)`; if desired, this functionality can be disabled
-      # by setting `UseAnonymousForwarding: false`.
+      # This cop also identifies places where `+use_args(*args)+`/`+use_kwargs(**kwargs)+` can be
+      # replaced by `+use_args(*)+`/`+use_kwargs(**)+`; if desired, this functionality can be
+      # disabled by setting `UseAnonymousForwarding: false`.
       #
       # And this cop has `RedundantRestArgumentNames`, `RedundantKeywordRestArgumentNames`,
       # and `RedundantBlockArgumentNames` options. This configuration is a list of redundant names
       # that are sufficient for anonymizing meaningless naming.
       #
       # Meaningless names that are commonly used can be anonymized by default:
-      # e.g., `*args`, `**options`, `&block`, and so on.
+      # e.g., `+*args+`, `+**options+`, `&block`, and so on.
       #
       # Names not on this list are likely to be meaningful and are allowed by default.
       #
@@ -146,7 +146,7 @@ module RuboCop
         minimum_target_ruby_version 2.7
 
         FORWARDING_LVAR_TYPES = %i[splat kwsplat block_pass].freeze
-        ADDITIONAL_ARG_TYPES = %i[lvar arg].freeze
+        ADDITIONAL_ARG_TYPES = %i[lvar arg optarg].freeze
 
         FORWARDING_MSG = 'Use shorthand syntax `...` for arguments forwarding.'
         ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
@@ -479,6 +479,9 @@ module RuboCop
           end
 
           def ruby_32_only_anonymous_forwarding?
+            # A block argument and an anonymous block argument are never passed together.
+            return false if @send_node.each_ancestor(:any_block).any?
+
             def_all_anonymous_args?(@def_node) && send_all_anonymous_args?(@send_node)
           end
 

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

@@ -131,21 +131,27 @@ module RuboCop
             "#{node.body.children.first.const_name}"
         end
 
+        # rubocop:disable Metrics/AbcSize
         def remove_end(corrector, body)
-          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          remove_begin_pos = if same_line?(body.loc.name, body.loc.end)
+                               body.loc.name.end_pos
+                             else
+                               body.loc.end.begin_pos - leading_spaces(body).size
+                             end
           adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
           range = range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
 
           corrector.remove(range)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def unindent(corrector, node)
           return unless node.body.children.last
 
           last_child_leading_spaces = leading_spaces(node.body.children.last)
-          return if leading_spaces(node).size == last_child_leading_spaces.size
+          return if spaces_size(leading_spaces(node)) == spaces_size(last_child_leading_spaces)
 
-          column_delta = configured_indentation_width - last_child_leading_spaces.size
+          column_delta = configured_indentation_width - spaces_size(last_child_leading_spaces)
           return if column_delta.zero?
 
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
@@ -155,6 +161,16 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
+        def spaces_size(spaces_string)
+          mapping = { "\t" => tab_indentation_width }
+          spaces_string.chars.sum { |character| mapping.fetch(character, 1) }
+        end
+
+        def tab_indentation_width
+          config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
+            configured_indentation_width
+        end
+
         def check_style(node, body, style)
           return if node.identifier.namespace&.cbase_type?
 

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

@@ -68,7 +68,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          def_node = node.each_ancestor(:def, :defs).first
+          def_node = node.each_ancestor(:any_def).first
           return if def_node &&
                     (allowed_method?(def_node.method_name) ||
                     matches_allowed_pattern?(def_node.method_name))

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

@@ -173,7 +173,7 @@ module RuboCop
         end
 
         def preferred_delimiters_config
-          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']
+          config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
         end
       end
     end

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

@@ -58,7 +58,7 @@ module RuboCop
         REGEXP = /(?<keyword>\S+).*#/.freeze
 
         SUBCLASS_DEFINITION = /\A\s*class\s+(\w|::)+\s*<\s*(\w|::)+/.freeze
-        METHOD_DEFINITION = /\A\s*def\s/.freeze
+        METHOD_OR_END_DEFINITIONS = /\A\s*(def\s|end)/.freeze
 
         STEEP_REGEXP = /#\ssteep:ignore(\s|\z)/.freeze
 
@@ -102,7 +102,7 @@ module RuboCop
           case line
           when SUBCLASS_DEFINITION
             comment.text.start_with?(/#\[.+\]/)
-          when METHOD_DEFINITION
+          when METHOD_OR_END_DEFINITIONS
             comment.text.start_with?('#:')
           else
             false

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

@@ -9,6 +9,9 @@ module RuboCop
       # although the difference generally isn't observable. If you require maximum
       # performance, consider using logical comparison.
       #
+      # @safety
+      #   This cop is unsafe because the receiver may not respond to `between?`.
+      #
       # @example
       #
       #   # bad
@@ -61,8 +64,8 @@ module RuboCop
 
         def register_offense(node, min_and_value, max_and_value)
           value = (min_and_value & max_and_value).first
-          min = min_and_value.find { _1 != value }
-          max = max_and_value.find { _1 != value }
+          min = min_and_value.find { _1 != value } || value
+          max = max_and_value.find { _1 != value } || value
 
           prefer = "#{value.source}.between?(#{min.source}, #{max.source})"
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|

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

@@ -314,6 +314,7 @@ module RuboCop
 
         def assignment_node(node)
           assignment = node.send_type? ? node.last_argument : node.expression
+          return unless assignment
 
           # ignore pseudo-assignments without rhs in for nodes
           return if node.parent&.for_type?
@@ -436,19 +437,28 @@ module RuboCop
       # Helper module to provide common methods to ConditionalAssignment
       # correctors
       module ConditionalCorrectorHelper
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
             next if child.source_range.nil?
+            next if child.parent.dstr_type?
 
             white_space = white_space_range(child, column)
             corrector.remove(white_space) if white_space.source.strip.empty?
           end
 
-          [condition.loc.else, condition.loc.end].each do |loc|
-            next unless loc
-
-            corrector.remove_preceding(loc, loc.column - column)
+          if condition.loc.else && !same_line?(condition.else_branch, condition)
+            corrector.remove_preceding(condition.loc.else, condition.loc.else.column - column)
           end
+
+          return unless condition.loc.end && !same_line?(condition.loc.end, condition)
+
+          corrector.remove_preceding(condition.loc.end, condition.loc.end.column - column)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        def same_line?(node1, node2)
+          RuboCop::Cop::Util.same_line?(node1, node2)
         end
 
         def white_space_range(node, column)
@@ -595,6 +605,8 @@ module RuboCop
 
             return unless (branch_else = branch.parent.loc.else)
 
+            return if same_line?(branch_else, condition)
+
             corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Checks for inheritance from `Data.define` to avoid creating the anonymous parent class.
+      # Inheriting from `Data.define` adds a superfluous level in inheritance tree.
       #
       # @safety
       #   Autocorrection is unsafe because it will change the inheritance
@@ -17,12 +18,18 @@ module RuboCop
       #     end
       #   end
       #
+      #   Person.ancestors
+      #   # => [Person, #<Class:0x000000010b4e14a0>, Data, (...)]
+      #
       #   # good
       #   Person = Data.define(:first_name, :last_name) do
       #     def age
       #       42
       #     end
       #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, Data, (...)]
       class DataInheritance < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -25,8 +25,9 @@ module RuboCop
       #   # good
       #   def foo = do_something
       #
-      #   # good (without parentheses it's a syntax error)
+      #   # good - without parentheses it's a syntax error
       #   def foo() do_something end
+      #   def foo()=do_something
       #
       #   # bad
       #   def Baz.foo()
@@ -38,19 +39,31 @@ module RuboCop
       #     do_something
       #   end
       class DefWithParentheses < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = "Omit the parentheses in defs when the method doesn't accept any arguments."
 
         def on_def(node)
-          return if node.single_line? && !node.endless?
-          return unless !node.arguments? && (node_arguments = node.arguments.source_range)
+          return unless !node.arguments? && (arguments_range = node.arguments.source_range)
+          return if parentheses_required?(node, arguments_range)
 
-          add_offense(node_arguments) do |corrector|
-            corrector.remove(node_arguments)
+          add_offense(arguments_range) do |corrector|
+            corrector.remove(arguments_range)
           end
         end
         alias on_defs on_def
+
+        private
+
+        def parentheses_required?(node, arguments_range)
+          return true if node.single_line? && !node.endless?
+
+          end_pos = arguments_range.end.end_pos
+          token_after_argument = range_between(end_pos, end_pos + 1).source
+
+          token_after_argument == '='
+        end
       end
     end
   end

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

@@ -102,7 +102,7 @@ module RuboCop
 
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
-          return parent if parent.type?(:def, :defs)
+          return parent if parent.any_def_type?
           return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)

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

@@ -6,6 +6,10 @@ module RuboCop
       # Checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash, or string.
       #
+      # NOTE: When frozen string literals are enabled, `String.new`
+      # isn't corrected to an empty string since the former is
+      # mutable and the latter would be frozen.
+      #
       # @example
       #   # bad
       #   a = Array.new