rubocop 1.88.2 → 1.89.0

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

@@ -12,6 +12,17 @@ module RuboCop
       # Specific cops can be allowed with the `AllowedCops` configuration. Note that
       # if this configuration is set, `rubocop:disable all` is still disallowed.
       #
+      # Alternatively, specific cops can be disallowed with the `DisallowedCops`
+      # configuration. When `DisallowedCops` is set, only directives for the listed
+      # cops (and `all`) will be flagged. This is useful when you want
+      # to protect a small set of critical cops from being disabled rather than
+      # allowlisting all other cops. `AllowedCops` and `DisallowedCops` should not
+      # both be set at the same time; if `DisallowedCops` is set, it takes precedence.
+      #
+      # This cop cannot be disabled via directive comments when it is explicitly
+      # enabled with `Enabled: true`. This prevents users from bypassing the cop
+      # with `# rubocop:disable Style/DisableCopsWithinSourceCodeDirective`.
+      #
       # @example
       #   # bad
       #   # rubocop:disable Metrics/AbcSize
@@ -30,6 +41,17 @@ module RuboCop
       #   end
       #   # rubocop:enable Metrics/AbcSize
       #
+      # @example DisallowedCops: [Lint/Void]
+      #   # bad
+      #   # rubocop:disable Lint/Void
+      #   foo
+      #   # rubocop:enable Lint/Void
+      #
+      #   # good
+      #   # rubocop:disable Metrics/AbcSize
+      #   foo
+      #   # rubocop:enable Metrics/AbcSize
+      #
       class DisableCopsWithinSourceCodeDirective < Base
         extend AutoCorrector
 
@@ -40,7 +62,7 @@ module RuboCop
         def on_new_investigation
           processed_source.comments.each do |comment|
             directive_cops = directive_cops(comment)
-            disallowed_cops = directive_cops - allowed_cops
+            disallowed_cops = compute_disallowed_cops(directive_cops)
 
             next unless disallowed_cops.any?
 
@@ -50,8 +72,20 @@ module RuboCop
 
         private
 
+        def compute_disallowed_cops(directive_cops)
+          if disallowed_cops_config.any?
+            if directive_cops.include?('all')
+              directive_cops
+            else
+              directive_cops.uniq.select { |cop| disallowed_cops_config.include?(cop) }
+            end
+          else
+            directive_cops.reject { |cop| allowed_cops.include?(cop) }
+          end
+        end
+
         def register_offense(comment, directive_cops, disallowed_cops)
-          message = if any_cops_allowed?
+          message = if any_cops_allowed? || disallowed_cops_config.any?
                       format(MSG_FOR_COPS, cops: "`#{disallowed_cops.join('`, `')}`")
                     else
                       MSG
@@ -75,12 +109,16 @@ module RuboCop
         end
 
         def allowed_cops
-          Array(cop_config['AllowedCops'])
+          @allowed_cops ||= Array(cop_config['AllowedCops']).to_set
         end
 
         def any_cops_allowed?
           allowed_cops.any?
         end
+
+        def disallowed_cops_config
+          @disallowed_cops_config ||= Array(cop_config['DisallowedCops']).to_set
+        end
       end
     end
   end

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

@@ -13,6 +13,11 @@ module RuboCop
       # a `#:nodoc:` comment next to it. Likewise, `#:nodoc: all` does the
       # same for all its children.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, a reopened class or module is not reported when any of its
+      # other definition sites (in the same or another file) carries a
+      # documentation comment.
+      #
       # @example
       #   # bad
       #   class Person
@@ -71,10 +76,15 @@ module RuboCop
       #
       class Documentation < Base
         include DocumentationComment
+        include ProjectIndexHelp
         include RangeHelp
 
         MSG = 'Missing top-level documentation comment for `%<type>s %<identifier>s`.'
 
+        # Comments that configure tooling rather than document the code.
+        DIRECTIVE_COMMENT_REGEXP = /\A\#\s*(rubocop:|frozen_string_literal:|encoding:|
+                                            shareable_constant_value:|typed:|-\*-)/x.freeze
+
         # @!method constant_definition?(node)
         def_node_matcher :constant_definition?, '{class module casgn}'
 
@@ -109,12 +119,49 @@ module RuboCop
           return if constant_allowed?(node)
           return if nodoc_self_or_outer_module?(node)
           return if include_statement_only?(body)
+          return if documented_elsewhere?(node)
+
+          add_documentation_offense(node)
+        end
 
+        def add_documentation_offense(node)
           range = range_between(node.source_range.begin_pos, node.loc.name.end_pos)
           message = format(MSG, type: node.type, identifier: identifier(node))
           add_offense(range, message: message)
         end
 
+        # A reopened class or module is typically documented at a single
+        # definition site. When `AllCops/UseProjectIndex` is enabled, the
+        # documentation requirement is satisfied by a comment on any other
+        # definition of the same class or module.
+        def documented_elsewhere?(node)
+          return false unless project_index
+
+          declaration = resolve_constant_in_index(node.identifier)
+          return false unless declaration.is_a?(Rubydex::Namespace)
+
+          declaration.definitions.any? do |definition|
+            other_definition?(definition, node) && documenting_comments?(definition)
+          end
+        rescue StandardError
+          false
+        end
+
+        def other_definition?(definition, node)
+          location = definition.location
+          return false unless location.uri.start_with?(FILE_URI_PREFIX)
+
+          !same_file?(location.to_file_path, processed_source.file_path) ||
+            location.to_display.start_line != node.first_line
+        end
+
+        def documenting_comments?(definition)
+          definition.comments.to_a.any? do |comment|
+            text = comment.string.strip
+            !text.empty? && !DIRECTIVE_COMMENT_REGEXP.match?(text)
+          end
+        end
+
         def nodoc_self_or_outer_module?(node)
           nodoc_comment?(node) ||
             (compact_namespace?(node) && nodoc_comment?(outer_module(node).first))

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

@@ -206,16 +206,6 @@ module RuboCop
           body.each_descendant(:str).any?(&:heredoc?)
         end
 
-        def correct_to_multiline(corrector, node)
-          replacement = <<~RUBY.strip
-            def #{receiver(node)}#{node.method_name}#{arguments(node)}
-              #{node.body.source}
-            end
-          RUBY
-
-          corrector.replace(node, replacement)
-        end
-
         def endless_replacement(node)
           <<~RUBY.strip
             def #{receiver(node)}#{node.method_name}#{arguments(node)} = #{node.body.source}

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

@@ -72,10 +72,8 @@ module RuboCop
       #     do_something
       #   end
       #
-      class IfUnlessModifier < Base # rubocop:disable Metrics/ClassLength
+      class IfUnlessModifier < Base
         include StatementModifier
-        include LineLengthHelp
-        include AllowedPattern
         include RangeHelp
         include CommentsHelp
         extend AutoCorrector
@@ -83,6 +81,10 @@ module RuboCop
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
                            'single-line body. Another good alternative is ' \
                            'the usage of control flow `&&`/`||`.'
+        MSG_USE_MODIFIER_PARENS = 'Favor modifier `%<keyword>s` usage when having a ' \
+                                  'single-line body. Wrap the expression in parentheses ' \
+                                  'to keep the current behavior, as it is part of a ' \
+                                  'larger expression.'
         MSG_USE_NORMAL = 'Modifier form of `%<keyword>s` makes the line too long.'
 
         def self.autocorrect_incompatible_with
@@ -143,7 +145,7 @@ module RuboCop
 
         def message(node)
           if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
-            MSG_USE_MODIFIER
+            parenthesize?(node) ? MSG_USE_MODIFIER_PARENS : MSG_USE_MODIFIER
           elsif too_long_due_to_modifier?(node)
             MSG_USE_NORMAL
           end
@@ -188,52 +190,9 @@ module RuboCop
           max_line_length.between?(source_length - comment.source_range.length, source_length)
         end
 
-        def allowed_patterns
-          line_length_config = config.for_cop('Layout/LineLength')
-          line_length_config['AllowedPatterns'] || line_length_config['IgnoredPatterns'] || []
-        end
-
         def too_long_single_line?(node)
-          return false unless max_line_length
-
           range = node.source_range
-          return false unless range.single_line?
-          return false unless line_length_enabled_at_line?(range.first_line)
-
-          line = range.source_line
-          return false if line_length(line) <= max_line_length
-
-          too_long_line_based_on_config?(range, line)
-        end
-
-        def too_long_line_based_on_config?(range, line)
-          return false if matches_allowed_pattern?(line)
-
-          too_long = too_long_line_based_on_allow_cop_directives?(range, line)
-          return too_long unless too_long == :undetermined
-
-          too_long_line_based_on_allow_uri?(line)
-        end
-
-        def too_long_line_based_on_allow_cop_directives?(range, line)
-          if allow_cop_directives? && directive_on_source_line?(range.line - 1)
-            return line_length_without_directive(line) > max_line_length
-          end
-
-          :undetermined
-        end
-
-        def too_long_line_based_on_allow_uri?(line)
-          if allow_uri?
-            uri_range = find_excessive_range(line, :uri)
-            return false if uri_range && allowed_position?(line, uri_range)
-          end
-
-          true
-        end
-
-        def line_length_enabled_at_line?(line)
-          processed_source.comment_config.cop_enabled_at_line?('Layout/LineLength', line)
+          range.single_line? && !acceptable_line_length?(range.source_line, range.first_line)
         end
 
         def named_capture_in_condition?(node)

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

@@ -61,6 +61,10 @@ module RuboCop
           }
         }.freeze
 
+        def self.autocorrect_incompatible_with
+          [Style::SymbolProc]
+        end
+
         def on_block(node)
           return unless node.lambda?
 

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -8,11 +8,26 @@ module RuboCop
         # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
         module OmitParentheses
           include RangeHelp
+          include ReparsedEquivalence
 
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
           OMIT_MSG = 'Omit parentheses for method calls with arguments.'
           private_constant :OMIT_MSG
 
+          def on_investigation_end
+            # Each candidate's exact correction is verified by reparsing before
+            # the offense is registered, so an omission that would change how
+            # the code parses is never reported or offered.
+            verified_by_reparse(@pending_omit_offenses || []).each do |node|
+              add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
+                autocorrect(corrector, node)
+              end
+            end
+            @pending_omit_offenses = []
+
+            super
+          end
+
           private
 
           def omit_parentheses(node) # rubocop:disable Metrics/PerceivedComplexity
@@ -26,9 +41,11 @@ module RuboCop
             return if allowed_camel_case_method_call?(node)
             return if allowed_string_interpolation_method_call?(node)
 
-            add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
-              autocorrect(corrector, node)
-            end
+            (@pending_omit_offenses ||= []) << node
+          end
+
+          def apply_reparse_correction(corrector, node)
+            autocorrect(corrector, node)
           end
 
           def autocorrect(corrector, node)

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

@@ -28,6 +28,11 @@ module RuboCop
       # delegator.upcase # => FOO
       # ----
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, `respond_to_missing?` defined in another definition of the
+      # same class or module (e.g. a reopening in another file) also
+      # satisfies the check.
+      #
       # @example
       #   # bad
       #   def method_missing(name, *args)
@@ -52,11 +57,14 @@ module RuboCop
       #   end
       #
       class MissingRespondToMissing < Base
+        include ProjectIndexHelp
+
         MSG = 'When using `method_missing`, define `respond_to_missing?`.'
 
         def on_def(node)
           return unless node.method?(:method_missing)
           return if implements_respond_to_missing?(node)
+          return if respond_to_missing_elsewhere?(node)
 
           add_offense(node)
         end
@@ -64,6 +72,28 @@ module RuboCop
 
         private
 
+        # When `AllCops/UseProjectIndex` is enabled, `respond_to_missing?`
+        # defined in another definition of the same class or module (e.g. a
+        # reopening in another file) also satisfies the check. Ancestors are
+        # not consulted: overriding `method_missing` warrants a matching
+        # `respond_to_missing?` for the same class.
+        def respond_to_missing_elsewhere?(node)
+          return false unless project_index
+          return false unless (namespace_node = node.each_ancestor(:class, :module).first)
+
+          declaration = resolve_constant_in_index(namespace_node.identifier)
+          return false unless declaration.is_a?(Rubydex::Namespace)
+
+          scope = singleton_definition?(node) ? indexed_singleton_of(declaration) : declaration
+          !scope&.member('respond_to_missing?()').nil?
+        rescue StandardError
+          false
+        end
+
+        def singleton_definition?(node)
+          node.defs_type? || node.each_ancestor(:sclass, :class, :module).first&.sclass_type?
+        end
+
         def implements_respond_to_missing?(node)
           scope = enclosing_scope(node)
           search_root = scope || node.parent

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

@@ -36,7 +36,13 @@ module RuboCop
         private
 
         def non_modifier_then?(node)
-          node.multiline? && node.then? && node.loc.begin.line != node.if_branch&.loc&.line
+          node.multiline? && own_then?(node) && node.loc.begin.line != node.if_branch&.loc&.line
+        end
+
+        # Prism gives an `elsif` with no `then` of its own the previous branch's `then` location,
+        # which lies outside the node.
+        def own_then?(node)
+          node.then? && node.source_range.contains?(node.loc.begin)
         end
       end
     end

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

@@ -70,48 +70,59 @@ module RuboCop
           (send $_ :== ${lvar call})
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
         def on_or(node)
-          root_of_or_node = root_of_or_node(node)
-          return unless node == root_of_or_node
+          return unless node == root_of_or_node(node)
           return unless nested_comparison?(node)
-
-          return unless (variable, values = find_offending_var(node))
+          return unless (variable, values, skipped = find_offending_var(node))
           return if values.size < comparisons_threshold
 
           range = offense_range(values)
+          # Bail when an allowed method comparison sits between the collected
+          # values: collapsing them into a single `include?` would drop it.
+          return if skipped_within_range?(skipped, range)
 
           add_offense(range) do |corrector|
-            elements = values.map(&:source).join(', ')
-            argument = variable.lvar_type? ? variable_name(variable) : variable.source
-            prefer_method = "[#{elements}].include?(#{argument})"
-
-            corrector.replace(range, prefer_method)
+            corrector.replace(range, preferred_method(variable, values))
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def find_offending_var(node, variables = Set.new, values = [])
+        def skipped_within_range?(skipped, range)
+          skipped.any? { |node_part| range.contains?(node_part.source_range) }
+        end
+
+        def preferred_method(variable, values)
+          elements = values.map(&:source).join(', ')
+          argument = variable.lvar_type? ? variable_name(variable) : variable.source
+          "[#{elements}].include?(#{argument})"
+        end
+
+        def find_offending_var(node, variables = Set.new, values = [], skipped = [])
           if node.or_type?
-            find_offending_var(node.lhs, variables, values)
-            find_offending_var(node.rhs, variables, values)
+            find_offending_var(node.lhs, variables, values, skipped)
+            find_offending_var(node.rhs, variables, values, skipped)
           elsif simple_double_comparison?(node)
             return
-          elsif (var, obj = simple_comparison(node))
-            return if allow_method_comparison? && obj.call_type?
+          elsif (comparison = simple_comparison(node))
+            collect_comparison(node, comparison, variables, values, skipped)
+          end
 
-            variables << var
-            return if variables.size > 1
+          [variables.first, values, skipped] if variables.any?
+        end
 
-            values << obj
+        def collect_comparison(node, comparison, variables, values, skipped)
+          var, obj = comparison
+          if allow_method_comparison? && obj.call_type?
+            skipped << node
+            return
           end
 
-          [variables.first, values] if variables.any?
+          variables << var
+          return if variables.size > 1
+
+          values << obj
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def offense_range(values)
           values.first.parent.source_range.begin.join(values.last.parent.source_range.end)

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

@@ -89,6 +89,9 @@ module RuboCop
       #     end
       #   end.freeze
       #
+      #   # good - `Data.define` declares an immutable value type
+      #   CONST = Data.define(:foo, :bar)
+      #
       # @example
       #   # Magic comment - shareable_constant_value: literal
       #
@@ -319,6 +322,8 @@ module RuboCop
             (const _ _)
             (send (const {nil? cbase} :Struct) :new ...)
             (block (send (const {nil? cbase} :Struct) :new ...) ...)
+            (send (const {nil? cbase} :Data) :define ...)
+            (block (send (const {nil? cbase} :Data) :define ...) ...)
             (send _ :freeze)
             (send {float int} {:+ :- :* :** :/ :% :<<} _)
             (send _ {:+ :- :* :** :/ :%} {float int})

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

@@ -91,8 +91,9 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def range_with_length_subtraction?(range_node, array_receiver)
-          return false unless range_node.range_type?
+          return false unless range_node&.range_type?
 
           range_end = range_node.end
           range_start = range_node.begin
@@ -107,6 +108,7 @@ module RuboCop
 
           receivers_match_strict?(length_receiver, array_receiver)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def handle_range_pattern(receiver, range_node, index_arg)
           range_end = range_node.end

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # Checks for redundant assignment before returning.
       #
+      # When there are comments between the assignment and reference,
+      # the cop will report an offense but it will not autocorrect.
+      #
       # @example
       #   # bad
       #   def test
@@ -99,6 +102,8 @@ module RuboCop
         def check_begin_node(node)
           if (assignment = redundant_assignment?(node))
             add_offense(assignment) do |corrector|
+              next if comments_between_assignment_and_reference?(assignment)
+
               expression = assignment.children[1]
               corrector.replace(assignment, expression.source)
               corrector.remove(assignment.right_sibling)
@@ -108,6 +113,12 @@ module RuboCop
             check_branch(last_expr)
           end
         end
+
+        def comments_between_assignment_and_reference?(assignment)
+          line_span = assignment.source_range.line..assignment.right_sibling.source_range.line
+
+          processed_source.each_comment_in_lines(line_span).any?
+        end
       end
     end
   end

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

@@ -14,6 +14,11 @@ module RuboCop
       # to prevent conflicting rules. This is because it respects user configurations
       # that want to enable `Lint/ConstantResolution` cop which is disabled by default.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, a leading `::` inside a namespace is also reported when the
+      # constant provably resolves to the same declaration with and without
+      # the base, i.e. nothing in the surrounding nesting shadows it.
+      #
       # @example
       #   # bad
       #   ::Const
@@ -41,13 +46,14 @@ module RuboCop
       #     ::Const
       #   end
       class RedundantConstantBase < Base
+        include ProjectIndexHelp
         extend AutoCorrector
 
         MSG = 'Remove redundant `::`.'
 
         def on_cbase(node)
           return if lint_constant_resolution_cop_enabled?
-          return unless bad?(node)
+          return unless bad?(node) || provably_unshadowed?(node)
 
           add_offense(node) do |corrector|
             corrector.remove(node)
@@ -56,6 +62,36 @@ module RuboCop
 
         private
 
+        # When `AllCops/UseProjectIndex` is enabled, `::` inside a namespace is
+        # also redundant when the first constant segment resolves to the same
+        # declaration with and without the base, i.e. nothing in the
+        # surrounding nesting shadows it.
+        def provably_unshadowed?(node)
+          return false unless project_index
+          return false unless (segment = first_constant_segment(node))
+
+          nesting = module_nesting_ancestors_of(node)
+                    .map { |ancestor| ancestor.identifier.const_name }.reverse
+
+          !nesting.empty? && same_resolution?(segment, nesting)
+        rescue StandardError
+          false
+        end
+
+        def same_resolution?(segment, nesting)
+          relative = project_index.resolve_constant(segment, nesting)
+          absolute = project_index.resolve_constant(segment, [])
+
+          !relative.nil? && !absolute.nil? && relative.name == absolute.name
+        end
+
+        def first_constant_segment(node)
+          parent = node.parent
+          return nil unless parent&.const_type?
+
+          parent.short_name.to_s
+        end
+
         def lint_constant_resolution_cop_enabled?
           lint_constant_resolution_config.fetch('Enabled', false)
         end

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

@@ -41,6 +41,10 @@ module RuboCop
             return unless name_node.value.end_with?('.rb')
 
             extension_range = extension_range(name_node)
+            # A backslash right before the extension means the path is escaped;
+            # dropping the extension would either produce invalid Ruby (a trailing
+            # backslash escaping the closing quote) or a confusing path, so skip it.
+            return if escaped_extension?(name_node, extension_range)
 
             add_offense(extension_range) do |corrector|
               corrector.remove(extension_range)
@@ -55,6 +59,11 @@ module RuboCop
 
           range_between(end_of_path_string - 4, end_of_path_string - 1)
         end
+
+        def escaped_extension?(name_node, extension_range)
+          offset = extension_range.begin_pos - name_node.source_range.begin_pos
+          name_node.source[0...offset].end_with?('\\')
+        end
       end
     end
   end

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

@@ -182,8 +182,8 @@ module RuboCop
         def unknown_variable_width?(sequence, arguments)
           return false unless sequence.variable_width?
 
-          argument = arguments[sequence.variable_width_argument_number - 1]
-          !numeric?(argument)
+          argument = positional_argument(arguments, sequence.variable_width_argument_number)
+          argument.nil? || !numeric?(argument)
         end
 
         # rubocop:disable Metrics/AbcSize
@@ -195,7 +195,7 @@ module RuboCop
             arguments.delete_at(sequence.variable_width_argument_number - 1)
             arguments.shift
           elsif sequence.arg_number
-            arguments[sequence.arg_number.to_i - 1]
+            positional_argument(arguments, sequence.arg_number.to_i)
           else
             arguments.shift
           end
@@ -220,6 +220,15 @@ module RuboCop
           end
         end
 
+        # `Array#[]` raises `RangeError` for an index beyond the 64-bit range
+        # (e.g. `format('%*9999999999999999999999$d', 1)`) instead of returning `nil`,
+        # so the index needs to be checked before accessing the array.
+        def positional_argument(arguments, number)
+          index = number - 1
+
+          arguments[index] if index < arguments.size
+        end
+
         def numeric?(argument)
           argument.type?(:numeric, :str) ||
             rational_number?(argument) ||