rubocop 1.69.2 → 1.70.0

data/lib/rubocop/cop/layout/trailing_whitespace.rb

@@ -48,7 +48,7 @@ module RuboCop
 
         def on_new_investigation
           processed_source.lines.each_with_index do |line, index|
-            next unless line.end_with?(' ', "\t")
+            next unless line.match?(/[[:blank:]]\z/)
 
             process_line(line, index + 1)
           end
@@ -84,7 +84,7 @@ module RuboCop
         end
 
         def whitespace_is_indentation?(range, level)
-          range.source[/[ \t]+/].length <= level
+          range.source[/[[:blank:]]+/].length <= level
         end
 
         def whitespace_only?(range)
@@ -123,7 +123,9 @@ module RuboCop
         end
 
         def offense_range(lineno, line)
-          source_range(processed_source.buffer, lineno, (line.rstrip.length)...(line.length))
+          source_range(
+            processed_source.buffer, lineno, (line.sub(/[[:blank:]]+\z/, '').length)...(line.length)
+          )
         end
       end
     end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for constant reassignments.
+      #
+      # Emulates Ruby's runtime warning "already initialized constant X"
+      # when a constant is reassigned in the same file and namespace using the
+      # `NAME = value` syntax.
+      #
+      # The cop cannot catch all offenses, like, for example, when a constant
+      # is reassigned in another file, or when using metaprogramming (`Module#const_set`).
+      #
+      # The cop only takes into account constants assigned in a "simple" way: directly
+      # inside class/module definition, or within another constant. Other type of assignments
+      # (e.g., inside a conditional) are disregarded.
+      #
+      # The cop also tracks constant removal using `Module#remove_const` with symbol
+      # or string argument.
+      #
+      # @example
+      #   # bad
+      #   X = :foo
+      #   X = :bar
+      #
+      #   # bad
+      #   class A
+      #     X = :foo
+      #     X = :bar
+      #   end
+      #
+      #   # bad
+      #   module A
+      #     X = :foo
+      #     X = :bar
+      #   end
+      #
+      #   # good - keep only one assignment
+      #   X = :bar
+      #
+      #   class A
+      #     X = :bar
+      #   end
+      #
+      #   module A
+      #     X = :bar
+      #   end
+      #
+      #   # good - use OR assignment
+      #   X = :foo
+      #   X ||= :bar
+      #
+      #   # good - use conditional assignment
+      #   X = :foo
+      #   X = :bar unless defined?(X)
+      #
+      #   # good - remove the assigned constant first
+      #   class A
+      #     X = :foo
+      #     remove_const :X
+      #     X = :bar
+      #   end
+      #
+      class ConstantReassignment < Base
+        MSG = 'Constant `%<constant>s` is already assigned in this namespace.'
+
+        RESTRICT_ON_SEND = %i[remove_const].freeze
+
+        # @!method remove_constant(node)
+        def_node_matcher :remove_constant, <<~PATTERN
+          (send _ :remove_const
+            ({sym str} $_))
+        PATTERN
+
+        def on_casgn(node)
+          return unless fixed_constant_path?(node)
+          return unless simple_assignment?(node)
+          return if constant_names.add?(fully_qualified_constant_name(node))
+
+          add_offense(node, message: format(MSG, constant: node.name))
+        end
+
+        def on_send(node)
+          constant = remove_constant(node)
+
+          return unless constant
+
+          namespaces = ancestor_namespaces(node)
+
+          return if namespaces.none?
+
+          constant_names.delete(fully_qualified_name_for(namespaces, constant))
+        end
+
+        private
+
+        def fixed_constant_path?(node)
+          node.each_path.all? { |path| path.cbase_type? || path.const_type? || path.self_type? }
+        end
+
+        def simple_assignment?(node)
+          node.ancestors.all? do |ancestor|
+            return true if namespace_definition?(ancestor)
+
+            ancestor.begin_type? || ancestor.literal? || ancestor.casgn_type? ||
+              freeze_method?(ancestor)
+          end
+        end
+
+        def namespace_definition?(node)
+          node.module_type? || node.class_type?
+        end
+
+        def freeze_method?(node)
+          node.send_type? && node.method?(:freeze)
+        end
+
+        def fully_qualified_constant_name(node)
+          if node.absolute?
+            namespace = node.namespace.const_type? ? node.namespace.source : nil
+
+            "#{namespace}::#{node.name}"
+          else
+            constant_namespaces = ancestor_namespaces(node) + constant_namespaces(node)
+
+            fully_qualified_name_for(constant_namespaces, node.name)
+          end
+        end
+
+        def fully_qualified_name_for(namespaces, constant)
+          ['', *namespaces, constant].join('::')
+        end
+
+        def constant_namespaces(node)
+          node.each_path.select(&:const_type?).map(&:short_name)
+        end
+
+        def ancestor_namespaces(node)
+          node
+            .each_ancestor(:class, :module)
+            .map { |ancestor| ancestor.identifier.short_name }
+            .reverse
+        end
+
+        def constant_names
+          @constant_names ||= Set.new
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for duplicate literal, constant, or variable elements in Set.
+      # Checks for duplicate literal, constant, or variable elements in Set and SortedSet.
       #
       # @example
       #
@@ -25,17 +25,28 @@ module RuboCop
       #   # good
       #   [:foo, :bar].to_set
       #
+      #   # bad
+      #   SortedSet[:foo, :bar, :foo]
+      #
+      #   # good
+      #   SortedSet[:foo, :bar]
+      #
+      #   # bad
+      #   SortedSet.new([:foo, :bar, :foo])
+      #
+      #   # good
+      #   SortedSet.new([:foo, :bar])
       class DuplicateSetElement < Base
         extend AutoCorrector
 
-        MSG = 'Remove the duplicate element in Set.'
+        MSG = 'Remove the duplicate element in %<class_name>s.'
         RESTRICT_ON_SEND = %i[\[\] new to_set].freeze
 
         # @!method set_init_elements(node)
         def_node_matcher :set_init_elements, <<~PATTERN
           {
-            (send (const {nil? cbase} :Set) :[] $...)
-            (send (const {nil? cbase} :Set) :new (array $...))
+            (send (const {nil? cbase} {:Set :SortedSet}) :[] $...)
+            (send (const {nil? cbase} {:Set :SortedSet}) :new (array $...))
             (call (array $...) :to_set)
           }
         PATTERN
@@ -51,7 +62,7 @@ module RuboCop
             next if !set_element.literal? && !set_element.const_type? && !set_element.variable?
 
             if seen_elements.include?(set_element)
-              register_offense(set_element, set_elements[index - 1])
+              register_offense(set_element, set_elements[index - 1], node)
             else
               seen_elements << set_element
             end
@@ -61,8 +72,10 @@ module RuboCop
 
         private
 
-        def register_offense(current_element, prev_element)
-          add_offense(current_element) do |corrector|
+        def register_offense(current_element, prev_element, node)
+          class_name = node.receiver.const_type? ? node.receiver.const_name : 'Set'
+
+          add_offense(current_element, message: format(MSG, class_name: class_name)) do |corrector|
             range = prev_element.source_range.end.join(current_element.source_range.end)
 
             corrector.remove(range)

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

@@ -21,6 +21,7 @@ module RuboCop
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
+        # rubocop:disable Metrics/AbcSize
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
           return unless offending?(final_node)
@@ -35,11 +36,18 @@ module RuboCop
           return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
 
           add_offense(final_node) do |corrector|
-            return if final_node.dstr_type? # nested, fixed in next iteration
+            next if final_node.dstr_type? # nested, fixed in next iteration
 
-            corrector.replace(final_node.parent, expanded_value)
+            replacement = if final_node.str_type? && !final_node.value.valid_encoding?
+                            final_node.source.delete_prefix('"').delete_suffix('"')
+                          else
+                            expanded_value
+                          end
+
+            corrector.replace(final_node.parent, replacement)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -168,7 +176,7 @@ module RuboCop
         end
 
         def space_literal?(node)
-          node.str_type? && node.value.blank?
+          node.str_type? && node.value.valid_encoding? && node.value.blank?
         end
 
         def ends_heredoc_line?(node)

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

@@ -96,7 +96,7 @@ module RuboCop
 
         def on_def(node)
           subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
-          return if node.defs_type? && subject.variable?
+          return if node.defs_type? && allowed_subject_type?(subject)
 
           def_ancestor = node.each_ancestor(:def, :defs).first
           return unless def_ancestor
@@ -117,6 +117,10 @@ module RuboCop
             child.class_constructor? || allowed_method_name?(child)
         end
 
+        def allowed_subject_type?(subject)
+          subject.variable? || subject.const_type? || subject.call_type?
+        end
+
         def allowed_method_name?(node)
           name = node.method_name
 

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

@@ -59,12 +59,12 @@ module RuboCop
 
         # @!method send_exist_node(node)
         def_node_search :send_exist_node, <<~PATTERN
-          $(send (const nil? {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
+          $(send (const {cbase nil?} {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
         PATTERN
 
         # @!method receiver_and_method_name(node)
         def_node_matcher :receiver_and_method_name, <<~PATTERN
-          (send (const nil? $_) $_ ...)
+          (send (const {cbase nil?} $_) $_ ...)
         PATTERN
 
         # @!method force?(node)
@@ -78,7 +78,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.receiver
+          return unless node.receiver&.const_type?
           return unless if_node_child?(node)
           return if explicit_not_force?(node)
           return unless (exist_node = send_exist_node(node.parent).first)
@@ -116,6 +116,7 @@ module RuboCop
 
         def message_remove_file_exist_check(node)
           receiver, method_name = receiver_and_method_name(node)
+
           format(MSG_REMOVE_FILE_EXIST_CHECK, receiver: receiver, method_name: method_name)
         end
 

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

@@ -4,30 +4,27 @@ module RuboCop
   module Cop
     module Lint
       # Certain numeric operations have a constant result, usually 0 or 1.
-      # Subtracting a number from itself or multiplying it by 0 will always return 0.
-      # Additionally, a variable modulo 0 or itself will always return 0.
+      # Multiplying a number by 0 will always return 0.
       # Dividing a number by itself or raising it to the power of 0 will always return 1.
       # As such, they can be replaced with that result.
       # These are probably leftover from debugging, or are mistakes.
       # Other numeric operations that are similarly leftover from debugging or mistakes
       # are handled by Lint/UselessNumericOperation.
       #
+      # NOTE: This cop doesn't detect offenses for the `-` and `%` operator because it
+      # can't determine the type of `x`. If `x` is an Array or String, it doesn't perform
+      # a numeric operation.
+      #
       # @example
       #
       #   # bad
-      #   x - x
       #   x * 0
-      #   x % 1
-      #   x % x
       #
       #   # good
       #   0
       #
       #   # bad
-      #   x -= x
       #   x *= 0
-      #   x %= 1
-      #   x %= x
       #
       #   # good
       #   x = 0
@@ -49,7 +46,7 @@ module RuboCop
       class NumericOperationWithConstantResult < Base
         extend AutoCorrector
         MSG = 'Numeric operation with a constant result detected.'
-        RESTRICT_ON_SEND = %i[- * / % **].freeze
+        RESTRICT_ON_SEND = %i[* / **].freeze
 
         # @!method operation_with_constant_result?(node)
         def_node_matcher :operation_with_constant_result?,
@@ -85,21 +82,16 @@ module RuboCop
 
         private
 
-        # rubocop :disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def constant_result?(variable, operation, number)
           if number.to_s == '0'
             return 0 if operation == :*
             return 1 if operation == :**
-          elsif number.to_s == '1'
-            return 0 if operation == :%
           elsif number == variable
-            return 0 if %i[- %].include?(operation)
             return 1 if operation == :/
           end
           # If we weren't able to find any matches, return false so we can bail out.
           false
         end
-        # rubocop :enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for Hash creation with a mutable default value.
+      # Creating a Hash in such a way will share the default value
+      # across all keys, causing unexpected behavior when modifying it.
+      #
+      # For example, when the Hash was created with an Array as the argument,
+      # calling `hash[:foo] << 'bar'` will also change the value of all
+      # other keys that have not been explicitly assigned to.
+      #
+      # @example
+      #   # bad
+      #   Hash.new([])
+      #   Hash.new({})
+      #   Hash.new(Array.new)
+      #   Hash.new(Hash.new)
+      #
+      #   # okay -- In rare cases that intentionally have this behavior,
+      #   #   without disabling the cop, you can set the default explicitly.
+      #   h = Hash.new
+      #   h.default = []
+      #   h[:a] << 1
+      #   h[:b] << 2
+      #   h # => {:a => [1, 2], :b => [1, 2]}
+      #
+      #   # okay -- beware this will discard mutations and only remember assignments
+      #   Hash.new { Array.new }
+      #   Hash.new { Hash.new }
+      #   Hash.new { {} }
+      #   Hash.new { [] }
+      #
+      #   # good - frozen solution will raise an error when mutation attempted
+      #   Hash.new([].freeze)
+      #   Hash.new({}.freeze)
+      #
+      #   # good - using a proc will create a new object for each key
+      #   h = Hash.new
+      #   h.default_proc = ->(h, k) { [] }
+      #   h.default_proc = ->(h, k) { {} }
+      #
+      #   # good - using a block will create a new object for each key
+      #   Hash.new { |h, k| h[k] = [] }
+      #   Hash.new { |h, k| h[k] = {} }
+      class SharedMutableDefault < Base
+        MSG = 'Do not create a Hash with a mutable default value ' \
+              'as the default value can accidentally be changed.'
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method hash_initialized_with_mutable_shared_object?(node)
+        def_node_matcher :hash_initialized_with_mutable_shared_object?, <<~PATTERN
+          (send (const {nil? cbase} :Hash) :new {array hash (send (const {nil? cbase} {:Array :Hash}) :new)})
+        PATTERN
+
+        def on_send(node)
+          return unless hash_initialized_with_mutable_shared_object?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -6,9 +6,12 @@ module RuboCop
       # Repacks Parser's diagnostics/errors
       # into RuboCop's offenses.
       class Syntax < Base
+        LEVELS = %i[error fatal].freeze
+
         def on_other_file
           add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
-          processed_source.diagnostics.each do |diagnostic|
+          syntax_errors = processed_source.diagnostics.select { |d| LEVELS.include?(d.level) }
+          syntax_errors.each do |diagnostic|
             add_offense_from_diagnostic(diagnostic, processed_source.ruby_version)
           end
           super

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

@@ -55,12 +55,9 @@ module RuboCop
           return if node.each_descendant(:dstr).any?
 
           regexp_constructor(node) do |text|
-            Regexp::Parser.parse(text.value)&.each_expression do |expr|
+            parse_regexp(text.value)&.each_expression do |expr|
               detect_offenses(text, expr)
             end
-          rescue Regexp::Parser::Error
-            # Upon encountering an invalid regular expression,
-            # we aim to proceed and identify any remaining potential offenses.
           end
         end
 

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

@@ -113,7 +113,8 @@ module RuboCop
         end
 
         def check_expression(expr)
-          expr = expr.body if expr.if_type? && expr.modifier_form?
+          expr = expr.body if expr.if_type?
+          return unless expr
 
           check_literal(expr)
           check_var(expr)
@@ -229,7 +230,7 @@ module RuboCop
         end
 
         def autocorrect_void_expression(corrector, node)
-          return if node.parent.if_type? && node.parent.modifier_form?
+          return if node.parent.if_type?
 
           corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
         end

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

@@ -48,7 +48,7 @@ module RuboCop
         LABEL = 'Method'
 
         def on_def(node)
-          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+          return if allowed?(node.method_name)
 
           check_code_length(node)
         end
@@ -57,6 +57,9 @@ module RuboCop
         def on_block(node)
           return unless node.method?(:define_method)
 
+          method_name = node.send_node.first_argument
+          return if method_name.basic_literal? && allowed?(method_name.value)
+
           check_code_length(node)
         end
         alias on_numblock on_block
@@ -66,6 +69,10 @@ module RuboCop
         def cop_label
           LABEL
         end
+
+        def allowed?(method_name)
+          allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+        end
       end
     end
   end

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

@@ -43,7 +43,7 @@ module RuboCop
     # (Note: Passes may not happen exactly in this sequence.)
     module CheckLineBreakable
       def extract_breakable_node(node, max)
-        if node.send_type?
+        if node.call_type?
           return if chained_to_heredoc?(node)
 
           args = process_args(node.arguments)
@@ -74,9 +74,9 @@ module RuboCop
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
 
-        # If a `send` node is not parenthesized, don't move the first element, because it
+        # If a `send` or `csend` node is not parenthesized, don't move the first element, because it
         # can result in changed behavior or a syntax error.
-        if node.send_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
+        if node.call_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
           elements = elements.drop(1)
         end
 
@@ -98,10 +98,10 @@ module RuboCop
       end
 
       # @api private
-      # If a send node contains a heredoc argument, splitting cannot happen
+      # If a `send` or `csend` node contains a heredoc argument, splitting cannot happen
       # after the heredoc or else it will cause a syntax error.
       def shift_elements_for_heredoc_arg(node, elements, index)
-        return index unless node.send_type? || node.array_type?
+        return index unless node.call_type? || node.array_type?
 
         heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
         return index unless heredoc_index
@@ -156,7 +156,7 @@ module RuboCop
 
           if ancestor.hash_type? || ancestor.array_type?
             elements = ancestor.children
-          elsif ancestor.send_type?
+          elsif ancestor.call_type?
             elements = process_args(ancestor.arguments)
           else
             next
@@ -176,7 +176,7 @@ module RuboCop
             return children_could_be_broken_up?(ancestor.children)
           end
 
-          next unless ancestor.send_type?
+          next unless ancestor.call_type?
 
           args = process_args(ancestor.arguments)
           return children_could_be_broken_up?(args) if breakable_collection?(ancestor, args)

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

@@ -73,6 +73,8 @@ module RuboCop
             node.else_branch.loc.line
           elsif node.elsif?
             node.each_ancestor(:if).find(&:if?).loc.end.line
+          elsif node.if? && node.parent && parentheses?(node.parent)
+            node.parent.loc.end.line
           end
         elsif node.block_type? || node.numblock_type?
           node.loc.end.line

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

@@ -20,7 +20,7 @@ module RuboCop
       private
 
       def dig_chain_enabled?
-        @config.for_cop('Style/DigChain')['Enabled']
+        @config.cop_enabled?('Style/DigChain')
       end
     end
   end