rubocop 1.82.1 → 1.84.0

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

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

@@ -8,20 +8,20 @@ module RuboCop
       #
       # @example
       #
-      #  # bad
-      #  tired? ? 'stop' : 'go faster' if running?
+      #   # bad
+      #   tired? ? 'stop' : 'go faster' if running?
       #
-      #  # bad
-      #  if tired?
-      #    "please stop"
-      #  else
-      #    "keep going"
-      #  end if running?
+      #   # bad
+      #   if tired?
+      #     "please stop"
+      #   else
+      #     "keep going"
+      #   end if running?
       #
-      #  # good
-      #  if running?
-      #    tired? ? 'stop' : 'go faster'
-      #  end
+      #   # good
+      #   if running?
+      #     tired? ? 'stop' : 'go faster'
+      #   end
       class IfUnlessModifierOfIfUnless < Base
         include StatementModifier
         extend AutoCorrector

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

@@ -6,18 +6,18 @@ module RuboCop
       # Checks for use of the lambda.(args) syntax.
       #
       # @example EnforcedStyle: call (default)
-      #  # bad
-      #  lambda.(x, y)
+      #   # bad
+      #   lambda.(x, y)
       #
-      #  # good
-      #  lambda.call(x, y)
+      #   # good
+      #   lambda.call(x, y)
       #
       # @example EnforcedStyle: braces
-      #  # bad
-      #  lambda.call(x, y)
+      #   # bad
+      #   lambda.call(x, y)
       #
-      #  # good
-      #  lambda.(x, y)
+      #   # good
+      #   lambda.(x, y)
       class LambdaCall < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector

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

@@ -26,33 +26,65 @@ module RuboCop
       #
       #   Array.method_defined?(:find, false)
       #
+      #   # bad
+      #   Array.class_variables.include?(:foo)
+      #   Array.constants.include?(:foo)
+      #   Array.private_instance_methods.include?(:foo)
+      #   Array.protected_instance_methods.include?(:foo)
+      #   Array.public_instance_methods.include?(:foo)
+      #   Array.included_modules.include?(:foo)
+      #
+      #   # good
+      #   Array.class_variable_defined?(:foo)
+      #   Array.const_defined?(:foo)
+      #   Array.private_method_defined?(:foo)
+      #   Array.protected_method_defined?(:foo)
+      #   Array.public_method_defined?(:foo)
+      #   Array.include?(:foo)
+      #
+      #  @example AllowedMethods: [included_modules]
+      #
+      #   # good
+      #   Array.included_modules.include?(:foo)
+      #
       class ModuleMemberExistenceCheck < Base
+        include AllowedMethods
         extend AutoCorrector
 
         MSG = 'Use `%<replacement>s` instead.'
 
-        RESTRICT_ON_SEND = %i[instance_methods].freeze
-
-        # @!method instance_methods_inclusion?(node)
-        def_node_matcher :instance_methods_inclusion?, <<~PATTERN
+        # @!method module_member_inclusion?(node)
+        def_node_matcher :module_member_inclusion?, <<~PATTERN
           (call
-            (call _ :instance_methods _?)
+            {(call _ %METHODS_WITH_INHERIT_PARAM _?) (call _ %METHODS_WITHOUT_INHERIT_PARAM)}
             {:include? :member?}
             _)
         PATTERN
 
-        def on_send(node) # rubocop:disable Metrics/AbcSize
+        METHOD_REPLACEMENTS = {
+          class_variables: :class_variable_defined?,
+          constants: :const_defined?,
+          included_modules: :include?,
+          instance_methods: :method_defined?,
+          private_instance_methods: :private_method_defined?,
+          protected_instance_methods: :protected_method_defined?,
+          public_instance_methods: :public_method_defined?
+        }.freeze
+
+        METHODS_WITHOUT_INHERIT_PARAM = Set[:class_variables, :included_modules].freeze
+        METHODS_WITH_INHERIT_PARAM =
+          (METHOD_REPLACEMENTS.keys.to_set - METHODS_WITHOUT_INHERIT_PARAM).freeze
+
+        RESTRICT_ON_SEND = METHOD_REPLACEMENTS.keys.freeze
+
+        def on_send(node)
           return unless (parent = node.parent)
-          return unless instance_methods_inclusion?(parent)
+          return unless module_member_inclusion?(parent)
           return unless simple_method_argument?(node) && simple_method_argument?(parent)
+          return if allowed_method?(node.method_name)
 
           offense_range = node.location.selector.join(parent.source_range.end)
-          replacement =
-            if node.first_argument.nil? || node.first_argument.true_type?
-              "method_defined?(#{parent.first_argument.source})"
-            else
-              "method_defined?(#{parent.first_argument.source}, #{node.first_argument.source})"
-            end
+          replacement = replacement_for(node, parent)
 
           add_offense(offense_range, message: format(MSG, replacement: replacement)) do |corrector|
             corrector.replace(offense_range, replacement)
@@ -62,6 +94,17 @@ module RuboCop
 
         private
 
+        def replacement_for(node, parent)
+          replacement_method = METHOD_REPLACEMENTS.fetch(node.method_name)
+          without_inherit_param = METHODS_WITHOUT_INHERIT_PARAM.include?(node.method_name)
+
+          if without_inherit_param || node.first_argument.nil? || node.first_argument.true_type?
+            "#{replacement_method}(#{parent.first_argument.source})"
+          else
+            "#{replacement_method}(#{parent.first_argument.source}, #{node.first_argument.source})"
+          end
+        end
+
         def simple_method_argument?(node)
           return false if node.splat_argument? || node.block_argument?
           return false if node.first_argument&.hash_type?