rubocop 1.72.1 → 1.81.7

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

@@ -6,6 +6,10 @@ module RuboCop
       # Checks for duplicated instance (or singleton) method
       # definitions.
       #
+      # NOTE: Aliasing a method to itself is allowed, as it indicates that
+      # the developer intends to suppress Ruby's method redefinition warnings.
+      # See https://bugs.ruby-lang.org/issues/13574.
+      #
       # @example
       #
       #   # bad
@@ -39,10 +43,64 @@ module RuboCop
       #   end
       #
       #   alias bar foo
+      #
+      #   # good
+      #   alias foo foo
+      #   def foo
+      #     1
+      #   end
+      #
+      #   # good
+      #   alias_method :foo, :foo
+      #   def foo
+      #     1
+      #   end
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #
+      #   # good
+      #   def foo
+      #     1
+      #   end
+      #
+      #   delegate :foo, to: :bar
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #
+      #   # bad
+      #   def foo
+      #     1
+      #   end
+      #
+      #   delegate :foo, to: :bar
+      #
+      #   # good
+      #   def foo
+      #     1
+      #   end
+      #
+      #   delegate :baz, to: :bar
+      #
+      #   # good - delegate with splat arguments is ignored
+      #   def foo
+      #     1
+      #   end
+      #
+      #   delegate :foo, **options
+      #
+      #   # good - delegate inside a condition is ignored
+      #   def foo
+      #     1
+      #   end
+      #
+      #   if cond
+      #     delegate :foo, to: :bar
+      #   end
+      #
       class DuplicateMethods < Base
         MSG = 'Method `%<method>s` is defined at both %<defined>s and %<current>s.'
-        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr].freeze
-        DEF_TYPES = %i[def defs].freeze
+        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr
+                              delegate].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -54,14 +112,12 @@ module RuboCop
           # if a method definition is inside an if, it is very likely
           # that a different definition is used depending on platform, etc.
           return if node.each_ancestor.any?(&:if_type?)
-          return if possible_dsl?(node)
 
           found_instance_method(node, node.method_name)
         end
 
         def on_defs(node)
           return if node.each_ancestor.any?(&:if_type?)
-          return if possible_dsl?(node)
 
           if node.receiver.const_type?
             _, const_name = *node.receiver
@@ -73,32 +129,48 @@ module RuboCop
 
         # @!method method_alias?(node)
         def_node_matcher :method_alias?, <<~PATTERN
-          (alias (sym $_name) sym)
+          (alias (sym $_name) (sym $_original_name))
         PATTERN
 
         def on_alias(node)
-          return unless (name = method_alias?(node))
+          name, original_name = method_alias?(node)
+          return unless name && original_name
+          return if name == original_name
           return if node.ancestors.any?(&:if_type?)
-          return if possible_dsl?(node)
 
           found_instance_method(node, name)
         end
 
         # @!method alias_method?(node)
         def_node_matcher :alias_method?, <<~PATTERN
-          (send nil? :alias_method (sym $_name) _)
+          (send nil? :alias_method (sym $_name) (sym $_original_name))
+        PATTERN
+
+        # @!method delegate_method?(node)
+        def_node_matcher :delegate_method?, <<~PATTERN
+          (send nil? :delegate
+            ({sym str} $_)+
+            (hash <(pair (sym :to) {sym str}) ...>)
+          )
         PATTERN
 
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
-        def on_send(node)
-          if (name = alias_method?(node))
+
+        def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          name, original_name = alias_method?(node)
+
+          if name && original_name
+            return if name == original_name
             return if node.ancestors.any?(&:if_type?)
-            return if possible_dsl?(node)
 
             found_instance_method(node, name)
           elsif (attr = node.attribute_accessor?)
             on_attr(node, *attr)
+          elsif active_support_extensions_enabled? && (names = delegate_method?(node))
+            return if node.ancestors.any?(&:if_type?)
+
+            on_delegate(node, names)
           end
         end
 
@@ -123,6 +195,32 @@ module RuboCop
                       current: source_location(node))
         end
 
+        def on_delegate(node, method_names)
+          name_prefix = delegate_prefix(node)
+
+          method_names.each do |name|
+            name = "#{name_prefix}_#{name}" if name_prefix
+
+            found_instance_method(node, name)
+          end
+        end
+
+        def delegate_prefix(node)
+          kwargs_node = node.last_argument
+
+          return unless (prefix = hash_value(kwargs_node, :prefix))
+
+          if prefix.true_type?
+            hash_value(kwargs_node, :to).value
+          elsif prefix.type?(:sym, :str)
+            prefix.value
+          end
+        end
+
+        def hash_value(node, key)
+          node.pairs.find { |pair| pair.key.value == key }&.value
+        end
+
         def found_instance_method(node, name)
           return found_sclass_method(node, name) unless (scope = node.parent_module_name)
 
@@ -166,7 +264,7 @@ module RuboCop
         end
 
         def method_key(node, method_name)
-          if (ancestor_def = node.each_ancestor(*DEF_TYPES).first)
+          if (ancestor_def = node.each_ancestor(:any_def).first)
             "#{ancestor_def.method_name}.#{method_name}"
           else
             method_name
@@ -174,7 +272,7 @@ module RuboCop
         end
 
         def location(node)
-          if DEF_TYPES.include?(node.type)
+          if node.any_def_type?
             node.loc.keyword.join(node.loc.name)
           else
             node.source_range
@@ -237,16 +335,6 @@ module RuboCop
           end
         end
 
-        def possible_dsl?(node)
-          # DSL methods may evaluate a block in the context of a newly created
-          # class or module
-          # Assume that if a method definition is inside any block call which
-          # we can't identify, it could be a DSL
-          node.each_ancestor(:block).any? do |ancestor|
-            !ancestor.method?(:class_eval) && !ancestor.class_constructor?
-          end
-        end
-
         def source_location(node)
           range = node.source_range
           path = smart_path(range.source_buffer.name)

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

@@ -24,8 +24,6 @@ module RuboCop
 
         MSG_REPEATED_ELEMENT = 'Duplicate element inside regexp character class'
 
-        OCTAL_DIGITS_AFTER_ESCAPE = 2
-
         def on_regexp(node)
           each_repeated_character_class_element_loc(node) do |loc|
             add_offense(loc, message: MSG_REPEATED_ELEMENT) do |corrector|
@@ -40,9 +38,9 @@ module RuboCop
 
             seen = Set.new
             group_expressions(node, expr.expressions) do |group|
-              group_source = group.map(&:to_s).join
+              group_source = group.to_s
 
-              yield source_range(group) if seen.include?(group_source)
+              yield group.expression if seen.include?(group_source)
 
               seen << group_source
             end
@@ -52,40 +50,13 @@ module RuboCop
         private
 
         def group_expressions(node, expressions)
-          # Create a mutable list to simplify state tracking while we iterate.
-          expressions = expressions.to_a
-
-          until expressions.empty?
-            # With we may need to compose a group of multiple expressions.
-            group = [expressions.shift]
-            next if within_interpolation?(node, group.first)
-
-            # With regexp_parser < 2.7 escaped octal sequences may be up to 3
-            # separate expressions ("\\0", "0", "1").
-            pop_octal_digits(group, expressions) if escaped_octal?(group.first.to_s)
-
-            yield(group)
-          end
-        end
-
-        def pop_octal_digits(current_child, expressions)
-          OCTAL_DIGITS_AFTER_ESCAPE.times do
-            next_child = expressions.first
-            break unless octal?(next_child.to_s)
+          expressions.each do |expression|
+            next if within_interpolation?(node, expression)
 
-            current_child << expressions.shift
+            yield(expression)
           end
         end
 
-        def source_range(children)
-          return children.first.expression if children.size == 1
-
-          range_between(
-            children.first.expression.begin_pos,
-            children.last.expression.begin_pos + children.last.to_s.length
-          )
-        end
-
         def skip_expression?(expr)
           expr.type != :set || expr.token == :intersection
         end
@@ -99,14 +70,6 @@ module RuboCop
           interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
         end
 
-        def escaped_octal?(string)
-          string.length == 2 && string[0] == '\\' && octal?(string[1])
-        end
-
-        def octal?(char)
-          ('0'..'7').cover?(char)
-        end
-
         def interpolation_locs(node)
           @interpolation_locs ||= {}
 

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

@@ -7,11 +7,6 @@ module RuboCop
       #
       # NOTE: empty `else` branches are handled by `Style/EmptyElse`.
       #
-      # @safety
-      #   Autocorrection for this cop is not safe. The conditions for empty branches that
-      #   the autocorrection removes may have side effects, or the logic in subsequent
-      #   branches may change due to the removal of a previous condition.
-      #
       # @example
       #   # bad
       #   if condition
@@ -41,6 +36,13 @@ module RuboCop
       #   if condition
       #     do_something
       #   elsif other_condition
+      #     nil
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
       #     do_something_else
       #   end
       #
@@ -63,11 +65,9 @@ module RuboCop
       class EmptyConditionalBody < Base
         extend AutoCorrector
         include CommentsHelp
-        include RangeHelp
 
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
-        # rubocop:disable Metrics/AbcSize
         def on_if(node)
           return if node.body || same_line?(node.loc.begin, node.loc.end)
           return if cop_config['AllowComments'] && contains_comments?(node)
@@ -75,12 +75,11 @@ module RuboCop
           range = offense_range(node)
 
           add_offense(range, message: format(MSG, keyword: node.keyword)) do |corrector|
-            next if node.parent&.call_type?
+            next unless can_simplify_conditional?(node)
 
-            autocorrect(corrector, node)
+            flip_orphaned_else(corrector, node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -92,53 +91,23 @@ module RuboCop
           end
         end
 
-        def autocorrect(corrector, node)
-          remove_comments(corrector, node)
-          remove_empty_branch(corrector, node)
-          correct_other_branches(corrector, node)
-        end
-
-        def remove_comments(corrector, node)
-          comments_in_range(node).each do |comment|
-            range = range_by_whole_lines(comment.source_range, include_final_newline: true)
-            corrector.remove(range)
-          end
+        def can_simplify_conditional?(node)
+          node.else_branch && node.loc.else.source == 'else'
         end
 
-        # rubocop:disable Metrics/AbcSize
         def remove_empty_branch(corrector, node)
           range = if empty_if_branch?(node) && else_branch?(node)
                     branch_range(node)
-                  elsif same_line?(node, else_kw_loc = node.loc.else)
-                    node.source_range.begin.join(else_kw_loc.begin)
-                  elsif node.parent&.loc.respond_to?(:end) &&
-                        same_line?(node, end_loc = node.parent.loc.end)
-                    node.source_range.begin.join(end_loc.begin)
                   else
                     deletion_range(branch_range(node))
                   end
 
           corrector.remove(range)
         end
-        # rubocop:enable Metrics/AbcSize
-
-        def correct_other_branches(corrector, node)
-          return unless require_other_branches_correction?(node)
-
-          if node.else_branch&.if_type? && !node.else_branch.modifier_form?
-            # Replace an orphaned `elsif` with `if`
-            corrector.replace(node.else_branch.loc.keyword, 'if')
-          else
-            # Flip orphaned `else`
-            corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
-          end
-        end
-
-        def require_other_branches_correction?(node)
-          return false unless node.if_type? && node.else?
-          return false if !empty_if_branch?(node) && node.elsif?
 
-          !empty_elsif_branch?(node)
+        def flip_orphaned_else(corrector, node)
+          corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
+          remove_empty_branch(corrector, node)
         end
 
         def empty_if_branch?(node)
@@ -149,36 +118,17 @@ module RuboCop
           if_branch.if_type? && !if_branch.body
         end
 
-        def empty_elsif_branch?(node)
-          return false unless (else_branch = node.else_branch)
-
-          else_branch.if_type? && !else_branch.body
-        end
-
         def else_branch?(node)
           node.else_branch && !node.else_branch.if_type?
         end
 
-        # rubocop:disable Metrics/AbcSize
         def branch_range(node)
           if empty_if_branch?(node) && else_branch?(node)
             node.source_range.with(end_pos: node.loc.else.begin_pos)
           elsif node.loc.else
             node.source_range.with(end_pos: node.condition.source_range.end_pos)
-          elsif all_branches_body_missing?(node)
-            if_node = node.ancestors.detect(&:if?)
-            node.source_range.join(if_node.loc.end.end)
-          else
-            node.source_range
           end
         end
-        # rubocop:enable Metrics/AbcSize
-
-        def all_branches_body_missing?(node)
-          return false unless node.parent&.if_type?
-
-          node.parent.branches.compact.empty?
-        end
 
         def deletion_range(range)
           # Collect a range between the start of the `if` node and the next relevant node,

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

@@ -19,10 +19,23 @@ module RuboCop
         MSG = 'Empty interpolation detected.'
 
         def on_interpolation(begin_node)
-          return unless begin_node.children.empty?
+          return if in_percent_literal_array?(begin_node)
+
+          node_children = begin_node.children.dup
+          node_children.delete_if { |e| e.nil_type? || (e.basic_literal? && e.str_content&.empty?) }
+          return unless node_children.empty?
 
           add_offense(begin_node) { |corrector| corrector.remove(begin_node) }
         end
+
+        private
+
+        def in_percent_literal_array?(begin_node)
+          array_node = begin_node.each_ancestor(:array).first
+          return false unless array_node
+
+          array_node.percent_literal?
+        end
       end
     end
   end

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

@@ -156,12 +156,6 @@ module RuboCop
 
           overridden_kwargs
         end
-
-        def arguments_range(node)
-          arguments = node.arguments
-
-          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
-        end
       end
     end
   end

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

@@ -15,6 +15,14 @@ module RuboCop
       #   x == 0.1
       #   x != 0.1
       #
+      #   # bad
+      #   case value
+      #   when 1.0
+      #     foo
+      #   when 2.0
+      #     bar
+      #   end
+      #
       #   # good - using BigDecimal
       #   x.to_d == 0.1.to_d
       #
@@ -32,12 +40,21 @@ module RuboCop
       #   # good - comparing against nil
       #   Float(x, exception: false) == nil
       #
+      #   # good - using epsilon comparison in case expression
+      #   case
+      #   when (value - 1.0).abs < Float::EPSILON
+      #     foo
+      #   when (value - 2.0).abs < Float::EPSILON
+      #     bar
+      #   end
+      #
       #   # Or some other epsilon based type of comparison:
       #   # https://www.embeddeduse.com/2019/08/26/qt-compare-two-floats/
       #
       class FloatComparison < Base
         MSG_EQUALITY = 'Avoid equality comparisons of floats as they are unreliable.'
         MSG_INEQUALITY = 'Avoid inequality comparisons of floats as they are unreliable.'
+        MSG_CASE = 'Avoid float literal comparisons in case statements as they are unreliable.'
 
         EQUALITY_METHODS = %i[== != eql? equal?].freeze
         FLOAT_RETURNING_METHODS = %i[to_f Float fdiv].freeze
@@ -58,6 +75,16 @@ module RuboCop
         end
         alias on_csend on_send
 
+        def on_case(node)
+          node.when_branches.each do |when_branch|
+            when_branch.each_condition do |condition|
+              next if !float?(condition) || literal_safe?(condition)
+
+              add_offense(condition, message: MSG_CASE)
+            end
+          end
+        end
+
         private
 
         def float?(node)
@@ -67,7 +94,7 @@ module RuboCop
           when :float
             true
           when :send
-            check_send(node)
+            float_send?(node)
           when :begin
             float?(node.children.first)
           else
@@ -81,23 +108,18 @@ module RuboCop
           (node.numeric_type? && node.value.zero?) || node.nil_type?
         end
 
-        # rubocop:disable Metrics/PerceivedComplexity
-        def check_send(node)
+        def float_send?(node)
           if node.arithmetic_operation?
             float?(node.receiver) || float?(node.first_argument)
           elsif FLOAT_RETURNING_METHODS.include?(node.method_name)
             true
           elsif node.receiver&.float_type?
-            if FLOAT_INSTANCE_METHODS.include?(node.method_name)
-              true
-            else
-              check_numeric_returning_method(node)
-            end
+            FLOAT_INSTANCE_METHODS.include?(node.method_name) ||
+              numeric_returning_method?(node)
           end
         end
-        # rubocop:enable Metrics/PerceivedComplexity
 
-        def check_numeric_returning_method(node)
+        def numeric_returning_method?(node)
           return false unless node.receiver
 
           case node.method_name

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

@@ -11,39 +11,43 @@ module RuboCop
       # @example
       #   # bad
       #   foo.object_id == bar.object_id
+      #   foo.object_id != baz.object_id
       #
       #   # good
       #   foo.equal?(bar)
+      #   !foo.equal?(baz)
       #
       class IdentityComparison < Base
         extend AutoCorrector
 
-        MSG = 'Use `equal?` instead `==` when comparing `object_id`.'
-        RESTRICT_ON_SEND = %i[==].freeze
+        MSG = 'Use `%<bang>sequal?` instead of `%<comparison_method>s` when comparing `object_id`.'
+        RESTRICT_ON_SEND = %i[== !=].freeze
+
+        # @!method object_id_comparison(node)
+        def_node_matcher :object_id_comparison, <<~PATTERN
+          (send
+            (send
+              _lhs_receiver :object_id) ${:== :!=}
+            (send
+              _rhs_receiver :object_id))
+        PATTERN
 
         def on_send(node)
-          return unless compare_between_object_id_by_double_equal?(node)
+          return unless (comparison_method = object_id_comparison(node))
 
-          add_offense(node) do |corrector|
+          bang = comparison_method == :== ? '' : '!'
+          add_offense(node,
+                      message: format(MSG, comparison_method: comparison_method,
+                                           bang: bang)) do |corrector|
             receiver = node.receiver.receiver
             argument = node.first_argument.receiver
             return unless receiver && argument
 
-            replacement = "#{receiver.source}.equal?(#{argument.source})"
+            replacement = "#{bang}#{receiver.source}.equal?(#{argument.source})"
 
             corrector.replace(node, replacement)
           end
         end
-
-        private
-
-        def compare_between_object_id_by_double_equal?(node)
-          object_id_method?(node.receiver) && object_id_method?(node.first_argument)
-        end
-
-        def object_id_method?(node)
-          node.send_type? && node.method?(:object_id)
-        end
       end
     end
   end