rubocop 1.75.3 → 1.76.2

data/lib/rubocop/cop/lint/useless_or.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless OR (`||` and `or`) expressions.
+      #
+      # Some methods always return a truthy value, even when called
+      # on `nil` (e.g. `nil.to_i` evaluates to `0`). Therefore, OR expressions
+      # appended after these methods will never evaluate.
+      #
+      # @example
+      #
+      #   # bad
+      #   x.to_a || fallback
+      #   x.to_c || fallback
+      #   x.to_d || fallback
+      #   x.to_i || fallback
+      #   x.to_f || fallback
+      #   x.to_h || fallback
+      #   x.to_r || fallback
+      #   x.to_s || fallback
+      #   x.to_sym || fallback
+      #   x.intern || fallback
+      #   x.inspect || fallback
+      #   x.hash || fallback
+      #   x.object_id || fallback
+      #   x.__id__ || fallback
+      #
+      #   x.to_s or fallback
+      #
+      #   # good - if fallback is same as return value of method called on nil
+      #   x.to_a # nil.to_a returns []
+      #   x.to_c # nil.to_c returns (0+0i)
+      #   x.to_d # nil.to_d returns 0.0
+      #   x.to_i # nil.to_i returns 0
+      #   x.to_f # nil.to_f returns 0.0
+      #   x.to_h # nil.to_h returns {}
+      #   x.to_r # nil.to_r returns (0/1)
+      #   x.to_s # nil.to_s returns ''
+      #   x.to_sym # nil.to_sym raises an error
+      #   x.intern # nil.intern raises an error
+      #   x.inspect # nil.inspect returns "nil"
+      #   x.hash # nil.hash returns an Integer
+      #   x.object_id # nil.object_id returns an Integer
+      #   x.__id__ # nil.object_id returns an Integer
+      #
+      #   # good - if the intention is not to call the method on nil
+      #   x&.to_a || fallback
+      #   x&.to_c || fallback
+      #   x&.to_d || fallback
+      #   x&.to_i || fallback
+      #   x&.to_f || fallback
+      #   x&.to_h || fallback
+      #   x&.to_r || fallback
+      #   x&.to_s || fallback
+      #   x&.to_sym || fallback
+      #   x&.intern || fallback
+      #   x&.inspect || fallback
+      #   x&.hash || fallback
+      #   x&.object_id || fallback
+      #   x&.__id__ || fallback
+      #
+      #   x&.to_s or fallback
+      #
+      class UselessOr < Base
+        MSG = '`%<rhs>s` will never evaluate because `%<lhs>s` always returns a truthy value.'
+
+        TRUTHY_RETURN_VALUE_METHODS = Set[:to_a, :to_c, :to_d, :to_i, :to_f, :to_h, :to_r,
+                                          :to_s, :to_sym, :intern, :inspect, :hash, :object_id,
+                                          :__id__].freeze
+
+        # @!method truthy_return_value_method?(node)
+        def_node_matcher :truthy_return_value_method?, <<~PATTERN
+          (send _ %TRUTHY_RETURN_VALUE_METHODS)
+        PATTERN
+
+        def on_or(node)
+          if truthy_return_value_method?(node.lhs)
+            report_offense(node, node.lhs)
+          elsif truthy_return_value_method?(node.rhs)
+            parent = node.parent
+            parent = parent.parent if parent&.begin_type?
+
+            report_offense(parent, node.rhs) if parent&.or_type?
+          end
+        end
+
+        private
+
+        def report_offense(or_node, truthy_node)
+          add_offense(or_node.loc.operator.join(or_node.rhs.source_range),
+                      message: format(MSG, lhs: truthy_node.source, rhs: or_node.rhs.source))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/void.rb

@@ -128,8 +128,8 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_void_op(node, &block)
-          node = node.children.first while node.begin_type?
-          return unless node.call_type? && OPERATORS.include?(node.method_name)
+          node = node.children.first while node&.begin_type?
+          return unless node&.call_type? && OPERATORS.include?(node.method_name)
           if !UNARY_OPERATORS.include?(node.method_name) && node.loc.dot && node.arguments.none?
             return
           end

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -39,7 +39,7 @@ module RuboCop
       class AbcSize < Base
         include MethodComplexity
 
-        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
+        MSG = 'Assignment Branch Condition size for `%<method>s` is too high. ' \
               '[%<abc_vector>s %<complexity>.4g/%<max>.4g]'
 
         private

data/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -89,7 +89,7 @@ module RuboCop
 
         if first_non_comment_token
           # `line` is 1-indexed so we need to subtract 1 to get the array index
-          processed_source.lines[0...first_non_comment_token.line - 1]
+          processed_source.lines[0...(first_non_comment_token.line - 1)]
         else
           processed_source.lines
         end

data/lib/rubocop/cop/mixin/hash_alignment_styles.rb

@@ -10,7 +10,7 @@ module RuboCop
           true
         end
 
-        def deltas_for_first_pair(first_pair, _node)
+        def deltas_for_first_pair(first_pair)
           {
             separator: separator_delta(first_pair),
             value: value_delta(first_pair)
@@ -81,13 +81,7 @@ module RuboCop
       class TableAlignment
         include ValueAlignment
 
-        def initialize
-          self.max_key_width = 0
-        end
-
-        def deltas_for_first_pair(first_pair, node)
-          self.max_key_width = node.keys.map { |key| key.source.length }.max
-
+        def deltas_for_first_pair(first_pair)
           separator_delta = separator_delta(first_pair, first_pair, 0)
           {
             separator: separator_delta,
@@ -97,30 +91,37 @@ module RuboCop
 
         private
 
-        attr_accessor :max_key_width
-
         def key_delta(first_pair, current_pair)
           first_pair.key_delta(current_pair)
         end
 
         def hash_rocket_delta(first_pair, current_pair)
-          first_pair.loc.column + max_key_width + 1 - current_pair.loc.operator.column
+          first_pair.loc.column + max_key_width(first_pair.parent) + 1 -
+            current_pair.loc.operator.column
         end
 
         def value_delta(first_pair, current_pair)
           correct_value_column = first_pair.key.loc.column +
-                                 current_pair.delimiter(true).length +
-                                 max_key_width
+                                 max_key_width(first_pair.parent) +
+                                 max_delimiter_width(first_pair.parent)
 
           current_pair.value_omission? ? 0 : correct_value_column - current_pair.value.loc.column
         end
+
+        def max_key_width(hash_node)
+          hash_node.keys.map { |key| key.source.length }.max
+        end
+
+        def max_delimiter_width(hash_node)
+          hash_node.pairs.map { |pair| pair.delimiter(true).length }.max
+        end
       end
 
       # Handles calculation of deltas when the enforced style is 'separator'.
       class SeparatorAlignment
         include ValueAlignment
 
-        def deltas_for_first_pair(*_nodes)
+        def deltas_for_first_pair(_first_pair)
           {}
         end
 

data/lib/rubocop/cop/mixin/ordered_gem_node.rb

@@ -24,7 +24,7 @@ module RuboCop
         gem_canonical_name(string_a) < gem_canonical_name(string_b)
       end
 
-      def consecutive_lines(previous, current)
+      def consecutive_lines?(previous, current)
         first_line = get_source_range(current, treat_comments_as_separators).first_line
         previous.source_range.last_line == first_line - 1
       end

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -107,7 +107,7 @@ module RuboCop
       # of the argument is not considered multiline, even if the argument
       # itself might span multiple lines.
       def allowed_multiline_argument?(node)
-        elements(node).one? && !Util.begins_its_line?(node.loc.end)
+        elements(node).one? && !Util.begins_its_line?(node_end_location(node))
       end
 
       def elements(node)
@@ -127,10 +127,14 @@ module RuboCop
 
       def no_elements_on_same_line?(node)
         items = elements(node).map(&:source_range)
-        items << node.loc.end
+        items << node_end_location(node)
         items.each_cons(2).none? { |a, b| on_same_line?(a, b) }
       end
 
+      def node_end_location(node)
+        node.loc.end || node.source_range.end.adjust(begin_pos: -1)
+      end
+
       def on_same_line?(range1, range2)
         range1.last_line == range2.line
       end

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

@@ -0,0 +1,245 @@
+# 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. The cop also has `AllowedPatterns`
+      # configuration to allow method names by regular expression.
+      #
+      # The cop can furthermore be configured to allow all bang methods (method names
+      # ending with `!`), with `AllowBangMethods: true` (default false).
+      #
+      # @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
+      #
+      # @example AllowBangMethods: false (default)
+      #   # bad
+      #   def save!
+      #     true
+      #   end
+      #
+      # @example AllowBangMethods: true
+      #   # good
+      #   def save!
+      #     true
+      #   end
+      #
+      class PredicateMethod < Base
+        include AllowedMethods
+        include AllowedPattern
+
+        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) ||
+            matches_allowed_pattern?(node.method_name) ||
+            allowed_bang_method?(node) ||
+            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
+
+        def allowed_bang_method?(node)
+          return false unless allow_bang_methods?
+
+          node.bang_method?
+        end
+
+        def allow_bang_methods?
+          cop_config.fetch('AllowBangMethods', false)
+        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

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

@@ -149,9 +149,9 @@ module RuboCop
           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)
@@ -161,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/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/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

@@ -451,7 +451,9 @@ module RuboCop
             corrector.remove_preceding(condition.loc.else, condition.loc.else.column - column)
           end
 
-          return unless condition.loc.end && !same_line?(condition.loc.end, condition)
+          return unless condition.loc.end && !same_line?(
+            condition.branches.last.parent.else_branch, condition.loc.end
+          )
 
           corrector.remove_preceding(condition.loc.end, condition.loc.end.column - column)
         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