rubocop 1.82.0 → 1.84.0

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

@@ -77,7 +77,7 @@ module RuboCop
 
         def on_case(node)
           node.when_branches.each do |when_branch|
-            when_branch.each_condition do |condition|
+            when_branch.conditions.each do |condition|
               next if !float?(condition) || literal_safe?(condition)
 
               add_offense(condition, message: MSG_CASE)

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

@@ -157,7 +157,7 @@ module RuboCop
 
             check_case(case_match_node)
           else
-            case_match_node.each_in_pattern do |in_pattern_node|
+            case_match_node.in_pattern_branches.each do |in_pattern_node|
               next unless in_pattern_node.condition.literal?
 
               add_offense(in_pattern_node)

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

@@ -77,7 +77,7 @@ module RuboCop
         PERCENT_CAPITAL_W = '%W'
         PERCENT_I = '%i'
         PERCENT_CAPITAL_I = '%I'
-        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
 
         # @!method array_new?(node)
         def_node_matcher :array_new?, <<~PATTERN

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

@@ -26,7 +26,23 @@ module RuboCop
               'and it may be unexpected.'
         RESTRICT_ON_SEND = %i[new].freeze
 
-        STRUCT_METHOD_NAMES = Struct.instance_methods
+        # This is based on `Struct.instance_methods.sort` in Ruby 4.0.0.
+        STRUCT_METHOD_NAMES = %i[
+          ! != !~ <=> == === [] []= __id__ __send__ all? any? chain chunk chunk_while class clone
+          collect collect_concat compact count cycle deconstruct deconstruct_keys
+          define_singleton_method detect dig display drop drop_while dup each each_cons each_entry
+          each_pair each_slice each_with_index each_with_object entries enum_for eql? equal? extend
+          filter filter_map find find_all find_index first flat_map freeze frozen? grep grep_v
+          group_by hash include? inject inspect instance_eval instance_exec instance_of?
+          instance_variable_defined? instance_variable_get instance_variable_set instance_variables
+          is_a? itself kind_of? lazy length map max max_by member? members method methods
+          min min_by minmax minmax_by nil? none? object_id one? partition private_methods
+          protected_methods public_method public_methods public_send reduce reject
+          remove_instance_variable respond_to? reverse_each select send singleton_class
+          singleton_method singleton_methods size slice_after slice_before slice_when sort sort_by
+          sum take take_while tally tap then to_a to_enum to_h to_s to_set uniq values values_at
+          yield_self zip
+        ].freeze
         STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze
 
         # @!method struct_new(node)

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

@@ -5,27 +5,23 @@ module RuboCop
     module Lint
       # Checks to make sure `#to_json` includes an optional argument.
       # When overriding `#to_json`, callers may invoke JSON
-      # generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
+      # generation via `JSON.generate(your_obj)`. Since `JSON#generate` allows
       # for an optional argument, your method should too.
       #
       # @example
-      #   class Point
-      #     attr_reader :x, :y
-      #
-      #     # bad, incorrect arity
-      #     def to_json
-      #       JSON.generate([x, y])
-      #     end
+      #   # bad - incorrect arity
+      #   def to_json
+      #     JSON.generate([x, y])
+      #   end
       #
-      #     # good, preserving args
-      #     def to_json(*args)
-      #       JSON.generate([x, y], *args)
-      #     end
+      #   # good - preserving args
+      #   def to_json(*args)
+      #     JSON.generate([x, y], *args)
+      #   end
       #
-      #     # good, discarding args
-      #     def to_json(*_args)
-      #       JSON.generate([x, y])
-      #     end
+      #   # good - discarding args
+      #   def to_json(*_args)
+      #     JSON.generate([x, y])
       #   end
       #
       class ToJSON < Base

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

@@ -52,32 +52,39 @@ module RuboCop
           scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
         def check_for_unused_assignments(variable)
           return if variable.should_be_unused?
 
           variable.assignments.reverse_each do |assignment|
-            assignment_node = assignment.node
-            next if assignment.used? || part_of_ignored_node?(assignment_node)
+            check_for_unused_assignment(variable, assignment)
+          end
+        end
 
-            message = message_for_useless_assignment(assignment)
-            range = offense_range(assignment)
+        def check_for_unused_assignment(variable, assignment)
+          assignment_node = assignment.node
 
-            add_offense(range, message: message) do |corrector|
-              # In cases like `x = 1, y = 2`, where removing a variable would cause a syntax error,
-              # and where changing `x ||= 1` to `x = 1` would cause `NameError`,
-              # the autocorrect will be skipped, even if the variable is unused.
-              if sequential_assignment?(assignment_node) || assignment_node.parent&.or_asgn_type?
-                next
-              end
+          return if ignored_assignment?(variable, assignment_node, assignment)
 
-              autocorrect(corrector, assignment)
-            end
+          message = message_for_useless_assignment(assignment)
+          range = offense_range(assignment)
 
-            ignore_node(assignment_node) if chained_assignment?(assignment_node)
+          add_offense(range, message: message) do |corrector|
+            # In cases like `x = 1, y = 2`, where removing a variable would cause a syntax error,
+            # and where changing `x ||= 1` to `x = 1` would cause `NameError`,
+            # the autocorrect will be skipped, even if the variable is unused.
+            next if sequential_assignment?(assignment_node) ||
+                    assignment_node.parent&.or_asgn_type?
+
+            autocorrect(corrector, assignment)
           end
+
+          ignore_node(assignment_node) if chained_assignment?(assignment_node)
+        end
+
+        def ignored_assignment?(variable, assignment_node, assignment)
+          assignment.used? || part_of_ignored_node?(assignment_node) ||
+            variable_in_loop_condition?(assignment_node, variable)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
@@ -208,6 +215,27 @@ module RuboCop
         def remove_local_variable_assignment_part(corrector, node)
           corrector.replace(node, node.expression.source)
         end
+
+        def variable_in_loop_condition?(assignment_node, variable)
+          return false if assignment_node.each_ancestor(:any_def).any?
+
+          loop_node = assignment_node.each_ancestor.find do |ancestor|
+            ancestor.type?(*VariableForce::LOOP_TYPES)
+          end
+
+          return false unless loop_node.respond_to?(:condition)
+
+          condition_node = loop_node.condition
+          variable_name = variable.name
+
+          return true if condition_node.lvar_type? && condition_node.children.first == variable_name
+
+          condition_node.each_descendant(:lvar) do |lvar_node|
+            return true if lvar_node.children.first == variable_name
+          end
+
+          false
+        end
       end
     end
   end

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

@@ -11,7 +11,7 @@ module RuboCop
       #
       # @safety
       #   As shown in the examples below, there are generally two possible ways to correct the
-      #   offense, but this cop’s autocorrection always chooses the option that preserves the
+      #   offense, but this cop's autocorrection always chooses the option that preserves the
       #   current behavior. While this does not change how the code behaves, that option is not
       #   necessarily the appropriate fix in every situation. For this reason, the autocorrection
       #   provided by this cop is considered unsafe.

data/lib/rubocop/cop/lint/utils/nil_receiver_checker.rb

@@ -53,7 +53,7 @@ module RuboCop
                 return true
               end
             when :when
-              node.each_condition do |condition|
+              node.conditions.each do |condition|
                 return true if _cant_be_nil?(condition, receiver)
               end
             when :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn

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

@@ -14,6 +14,8 @@ module RuboCop
       private
 
       def too_long?(node)
+        return false unless max_line_length
+
         lines = processed_source.lines[(node.first_line - 1)...node.last_line]
         to_single_line(lines.join("\n")).length > max_line_length
       end

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

@@ -125,7 +125,7 @@ module RuboCop
         return if dispatch_node.assignment_method?
         return if dispatch_node.parenthesized?
         return if dispatch_node.parent && parentheses?(dispatch_node.parent)
-        return if last_expression?(dispatch_node) && !method_dispatch_as_argument?(dispatch_node)
+        return if last_expression?(dispatch_node) && !requires_parentheses_context?(dispatch_node)
 
         def_node = node.each_ancestor(:call, :super, :yield).first
 
@@ -164,11 +164,11 @@ module RuboCop
         !assignment_node.right_sibling
       end
 
-      def method_dispatch_as_argument?(method_dispatch_node)
-        parent = method_dispatch_node.parent
+      def requires_parentheses_context?(node)
+        parent = node.parent
         return false unless parent
 
-        parent.type?(:call, :super, :yield)
+        parent.type?(:call, :if, :super, :until, :while, :yield)
       end
 
       def breakdown_value_types_of_hash(hash_node)

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

@@ -8,8 +8,8 @@ module RuboCop
       MSG = 'Space missing after %<token>s.'
 
       def on_new_investigation
-        each_missing_space(processed_source.tokens) do |token|
-          add_offense(token.pos, message: format(MSG, token: kind(token))) do |corrector|
+        each_missing_space(processed_source.tokens) do |token, kind|
+          add_offense(token.pos, message: format(MSG, token: kind)) do |corrector|
             PunctuationCorrector.add_space(corrector, token)
           end
         end
@@ -19,11 +19,12 @@ module RuboCop
 
       def each_missing_space(tokens)
         tokens.each_cons(2) do |token1, token2|
-          next unless kind(token1)
+          kind = kind(token1, token2)
+          next unless kind
           next unless space_missing?(token1, token2)
           next unless space_required_before?(token2)
 
-          yield token1
+          yield token1, kind
         end
       end
 

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

@@ -95,12 +95,16 @@ module RuboCop
         node.multiline? && !allowed_multiline_argument?(node)
       end
 
+      # rubocop:disable Metrics/AbcSize
       def method_name_and_arguments_on_same_line?(node)
         return false if !node.call_type? || node.last_line != node.last_argument.last_line
         return true if node.last_argument.hash_type? && node.last_argument.braces?
 
-        node.loc.selector.line == node.last_argument.last_line
+        line = node.loc.selector&.line || node.loc.line
+
+        line == node.last_argument.last_line
       end
+      # rubocop:enable Metrics/AbcSize
 
       # A single argument with the closing bracket on the same line as the end
       # of the argument is not considered multiline, even if the argument

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

@@ -63,17 +63,17 @@ module RuboCop
       #   end
       #
       # @example UseSorbetSigs: false (default)
-      #  # bad
-      #  sig { returns(String) }
-      #  def is_this_thing_on
-      #    "yes"
-      #  end
-      #
-      #  # good - Sorbet signature is not evaluated
-      #  sig { returns(String) }
-      #  def is_this_thing_on?
-      #    "yes"
-      #  end
+      #   # bad
+      #   sig { returns(String) }
+      #   def is_this_thing_on
+      #     "yes"
+      #   end
+      #
+      #   # good - Sorbet signature is not evaluated
+      #   sig { returns(String) }
+      #   def is_this_thing_on?
+      #     "yes"
+      #   end
       #
       # @example UseSorbetSigs: true
       #   # bad

data/lib/rubocop/cop/offense.rb

@@ -139,7 +139,8 @@ module RuboCop
       # @return [Parser::Source::Range]
       #   the range of the code that is highlighted
       def highlighted_area
-        Parser::Source::Range.new(source_line, column, column + column_length)
+        source_buffer = Parser::Source::Buffer.new(location.source_buffer.name, source: source_line)
+        Parser::Source::Range.new(source_buffer, column, column + column_length)
       end
 
       # @api private

data/lib/rubocop/cop/security/json_load.rb

@@ -52,7 +52,7 @@ module RuboCop
           (
             send (const {nil? cbase} :JSON) ${:load :restore}
             ...
-            !(hash `(sym $:create_additions))
+            !`(pair (sym :create_additions) _)
           )
         PATTERN
 

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

@@ -326,8 +326,7 @@ module RuboCop
           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(:class, :module).first)
-
+          elsif (ancestor = node.each_ancestor(:class, :module, :sclass).first)
             corrector.insert_before(ancestor.loc.end, "#{node.method_name}\n\n#{source}\n")
           else
             corrector.replace(node, "#{node.method_name}\n\n#{source}")

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

@@ -62,12 +62,12 @@ module RuboCop
       #
       # @example AllowedConstants: ['ClassMethods']
       #
-      #    # good
-      #    module A
-      #      module ClassMethods
-      #        # ...
-      #      end
-      #    end
+      #   # good
+      #   module A
+      #     module ClassMethods
+      #       # ...
+      #     end
+      #   end
       #
       class Documentation < Base
         include DocumentationComment

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

@@ -97,14 +97,14 @@ module RuboCop
       #
       # @example AllowedMethods: ['method_missing', 'respond_to_missing?']
       #
-      #    # good
-      #    class Foo
-      #      def method_missing(name, *args)
-      #      end
-      #
-      #      def respond_to_missing?(symbol, include_private)
-      #      end
-      #    end
+      #   # good
+      #   class Foo
+      #     def method_missing(name, *args)
+      #     end
+      #
+      #     def respond_to_missing?(symbol, include_private)
+      #     end
+      #   end
       #
       class DocumentationMethod < Base
         include DocumentationComment

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces consistent style for empty class definitions.
+      #
+      # This cop can enforce either a two-line class definition or `Class.new`
+      # for classes with no body.
+      #
+      # The supported styles are:
+      #
+      # * class_definition (default) - prefer two-line class definition over `Class.new`
+      # * class_new - prefer `Class.new` over class definition
+      #
+      # @example EnforcedStyle: class_definition (default)
+      #   # bad
+      #   FooError = Class.new(StandardError)
+      #
+      #   # okish
+      #   class FooError < StandardError; end
+      #
+      #   # good
+      #   class FooError < StandardError
+      #   end
+      #
+      # @example EnforcedStyle: class_new
+      #   # bad
+      #   class FooError < StandardError
+      #   end
+      #
+      #   # bad
+      #   class FooError < StandardError; end
+      #
+      #   # good
+      #   FooError = Class.new(StandardError)
+      #
+      class EmptyClassDefinition < Base
+        include ConfigurableEnforcedStyle
+        include Alignment
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_CLASS_DEFINITION =
+          'Prefer a two-line class definition over `Class.new` for classes with no body.'
+        MSG_CLASS_NEW = 'Prefer `Class.new` over class definition for classes with no body.'
+
+        # @!method class_new_assignment?(node)
+        def_node_matcher :class_new_assignment?, <<~PATTERN
+          (casgn _ _ (send (const _ :Class) :new ...))
+        PATTERN
+
+        def on_casgn(node)
+          return unless style == :class_definition
+          return unless node.expression
+
+          class_new_node = find_class_new_node(node.expression)
+          return if chained_with_any_method?(node.expression, class_new_node)
+          return if variable_parent_class?(class_new_node)
+
+          add_offense(node, message: MSG_CLASS_DEFINITION) do |corrector|
+            autocorrect_class_new(corrector, node)
+          end
+        end
+
+        def on_class(node)
+          return unless style == :class_new
+          return unless empty_class?(node)
+
+          add_offense(node, message: MSG_CLASS_NEW) do |corrector|
+            autocorrect_class_definition(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect_class_new(corrector, node)
+          indent = ' ' * node.loc.column
+          class_name = node.name
+          class_new_node = find_class_new_node(node.expression)
+          parent_class = extract_parent_class(class_new_node)
+
+          replacement = if parent_class
+                          "class #{class_name} < #{parent_class}\n#{indent}end"
+                        else
+                          "class #{class_name}\n#{indent}end"
+                        end
+
+          corrector.replace(node, replacement)
+        end
+
+        def autocorrect_class_definition(corrector, node)
+          source_line = processed_source.buffer.source_line(node.loc.line)
+          indent = source_line[/\A */]
+          class_name = node.identifier.source
+          parent_class = node.parent_class&.source
+          range = range_by_whole_lines(node.source_range, include_final_newline: true)
+
+          replacement = if parent_class
+                          "#{indent}#{class_name} = Class.new(#{parent_class})\n"
+                        else
+                          "#{indent}#{class_name} = Class.new\n"
+                        end
+
+          corrector.replace(range, replacement)
+        end
+
+        def extract_parent_class(class_new_node)
+          first_arg = class_new_node.first_argument
+          first_arg&.source
+        end
+
+        def variable_parent_class?(class_new_node)
+          first_arg = class_new_node.first_argument
+          return false unless first_arg
+
+          !first_arg.const_type?
+        end
+
+        def find_class_new_node(node)
+          return nil unless node.send_type?
+          return nil unless node.receiver&.const_type?
+
+          return node if node.receiver.const_name.to_sym == :Class && node.method?(:new)
+
+          nil
+        end
+
+        def chained_with_any_method?(expression_node, class_new_node)
+          return true unless expression_node == class_new_node
+
+          false
+        end
+
+        def empty_class?(node)
+          body = node.body
+          return true unless body
+
+          body.begin_type? && body.children.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -227,12 +227,15 @@ module RuboCop
           remove_whole_lines(corrector, node.loc.end)
           return unless node.else?
 
-          remove_whole_lines(corrector, leave_branch.source_range)
+          if leave_branch
+            remove_whole_lines(corrector, leave_branch.source_range)
+            corrector.insert_after(
+              heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"
+            )
+          end
+
           remove_whole_lines(corrector, node.loc.else)
           remove_whole_lines(corrector, range_of_branch_to_remove(node, guard))
-          corrector.insert_after(
-            heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"
-          )
         end
 
         def range_of_branch_to_remove(node, guard)

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of either `Hash#[]` or `Hash#fetch` for hash lookup.
+      #
+      # This cop can be configured to prefer either bracket-style (`[]`)
+      # or fetch-style lookup. It is disabled by default.
+      #
+      # When enforcing `fetch` style, only single-argument bracket access is flagged.
+      # When enforcing `brackets` style, only `fetch` calls with a single key
+      # argument are flagged (not those with default values or blocks).
+      #
+      # @safety
+      #   This cop is unsafe because `Hash#[]` and `Hash#fetch` have different
+      #   semantics. `Hash#[]` returns `nil` for missing keys, while `Hash#fetch`
+      #   raises a `KeyError`. Replacing one with the other can change program
+      #   behavior in cases where the key is missing.
+      #
+      #   Additionally, it cannot be guaranteed that the receiver is a `Hash`
+      #   or responds to the replacement method.
+      #
+      # @example EnforcedStyle: brackets (default)
+      #   # bad
+      #   hash.fetch(key)
+      #
+      #   # good
+      #   hash[key]
+      #
+      #   # good - fetch with default value is allowed
+      #   hash.fetch(key, default)
+      #
+      #   # good - fetch with block is allowed
+      #   hash.fetch(key) { default }
+      #
+      # @example EnforcedStyle: fetch
+      #   # bad
+      #   hash[key]
+      #
+      #   # good
+      #   hash.fetch(key)
+      #
+      class HashLookupMethod < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        BRACKET_MSG = 'Use `Hash#[]` instead of `Hash#fetch`.'
+        FETCH_MSG = 'Use `Hash#fetch` instead of `Hash#[]`.'
+
+        RESTRICT_ON_SEND = %i[[] fetch].freeze
+
+        def on_send(node)
+          if offense_for_brackets?(node)
+            add_offense(node.loc.selector, message: BRACKET_MSG) do |corrector|
+              correct_fetch_to_brackets(corrector, node)
+            end
+          elsif offense_for_fetch?(node)
+            add_offense(node, message: FETCH_MSG) do |corrector|
+              correct_brackets_to_fetch(corrector, node)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def offense_for_brackets?(node)
+          style == :brackets && node.receiver && node.method?(:fetch) && node.arguments.one? &&
+            !node.block_literal?
+        end
+
+        def offense_for_fetch?(node)
+          style == :fetch && node.method?(:[]) && node.arguments.one?
+        end
+
+        def correct_fetch_to_brackets(corrector, node)
+          receiver = node.receiver.source
+          key = node.first_argument.source
+          replacement = "#{receiver}[#{key}]"
+          replacement = "(#{replacement})" if node.csend_type?
+          corrector.replace(node, replacement)
+        end
+
+        def correct_brackets_to_fetch(corrector, node)
+          receiver = node.receiver.source
+          key = node.first_argument.source
+          operator = node.csend_type? ? '&.' : '.'
+          corrector.replace(node, "#{receiver}#{operator}fetch(#{key})")
+        end
+      end
+    end
+  end
+end