rubocop 1.53.0 → 1.90.0

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

@@ -25,10 +25,9 @@ module RuboCop
       #   # good
       #   def foo = do_something
       #
-      #   # good (without parentheses it's a syntax error)
+      #   # good - without parentheses it's a syntax error
       #   def foo() do_something end
-      #
-      # @example
+      #   def foo()=do_something
       #
       #   # bad
       #   def Baz.foo()
@@ -40,19 +39,35 @@ module RuboCop
       #     do_something
       #   end
       class DefWithParentheses < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = "Omit the parentheses in defs when the method doesn't accept any arguments."
 
         def on_def(node)
-          return if node.single_line? && !node.endless?
-          return unless !node.arguments? && (node_arguments = node.arguments.source_range)
+          return unless !node.arguments? && (arguments_range = node.arguments.source_range)
+          return if parentheses_required?(node, arguments_range)
 
-          add_offense(node_arguments) do |corrector|
-            corrector.remove(node_arguments)
+          add_offense(arguments_range) do |corrector|
+            corrector.remove(arguments_range)
           end
         end
         alias on_defs on_def
+
+        private
+
+        def parentheses_required?(node, arguments_range)
+          end_pos = arguments_range.end.end_pos
+          token_after_argument = range_between(end_pos, end_pos + 1).source
+
+          # A `;` after the parentheses (e.g. `def foo(); end`) already separates the
+          # signature from the body, so the parentheses can be removed (`def foo; end`).
+          return false if token_after_argument == ';'
+
+          return true if node.single_line? && !node.endless?
+
+          token_after_argument == '='
+        end
       end
     end
   end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for chained `dig` calls that can be collapsed into a single `dig`.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Enumerable` or does not have a nonstandard implementation
+      #   of `dig`.
+      #
+      # @example
+      #   # bad
+      #   x.dig(:foo).dig(:bar).dig(:baz)
+      #   x.dig(:foo, :bar).dig(:baz)
+      #   x.dig(:foo, :bar)&.dig(:baz)
+      #
+      #   # good
+      #   x.dig(:foo, :bar, :baz)
+      #
+      #   # good - `dig`s cannot be combined
+      #   x.dig(:foo).bar.dig(:baz)
+      #
+      class DigChain < Base
+        extend AutoCorrector
+        include CommentsHelp
+        include DigHelp
+
+        MSG = 'Use `%<replacement>s` instead of chaining.'
+        RESTRICT_ON_SEND = %i[dig].freeze
+
+        def on_send(node)
+          return if ignored_node?(node)
+          return unless node.loc.dot
+          return unless dig?(node)
+
+          range, arguments = inspect_chain(node)
+          return if invalid_arguments?(arguments)
+          return unless range
+
+          register_offense(node, range, arguments)
+        end
+        alias on_csend on_send
+
+        private
+
+        # Walk up the method chain while the receiver is `dig` with arguments.
+        def inspect_chain(node)
+          arguments = node.arguments.dup
+          end_range = node.source_range.end
+
+          while dig?(node = node.receiver)
+            begin_range = node.loc.selector
+            arguments.unshift(*node.arguments)
+            ignore_node(node)
+          end
+
+          return unless begin_range
+
+          [begin_range.join(end_range), arguments]
+        end
+
+        def invalid_arguments?(arguments)
+          # If any of the arguments are arguments forwarding (`...`), it can only be the
+          # first argument, or else the resulting code will have a syntax error.
+
+          return false unless arguments&.any?
+
+          forwarded_args_index = arguments.index(&:forwarded_args_type?)
+          forwarded_args_index && forwarded_args_index < (arguments.size - 1)
+        end
+
+        def register_offense(node, range, arguments)
+          arguments = arguments.map(&:source).join(', ')
+          replacement = "dig(#{arguments})"
+
+          add_offense(range, message: format(MSG, replacement: replacement)) do |corrector|
+            corrector.replace(range, replacement)
+
+            comments_in_range(node).reverse_each do |comment|
+              # Only relocate comments that the replacement destroys. A trailing
+              # comment after the chain survives in place, so moving it would
+              # duplicate it (and splitting the line drops the indentation).
+              next if comment.source_range.begin_pos >= range.end_pos
+
+              corrector.insert_before(node, "#{comment.source}\n")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -35,6 +35,10 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          # A trailing block (e.g. `Dir.each_child(path).none? { ... }`) changes
+          # the meaning and is not equivalent to `Dir.empty?`.
+          return if node.block_literal?
+
           offensive?(node) do |const_node, arg_node|
             replacement = "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})"
             add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for directive scopes that can be expressed with the tighter
+      # `disable-next` form: a `disable`/`enable` pair wrapping exactly one
+      # statement, or a `push`/`pop` that only disables cops around exactly
+      # one statement. A statement-scoped directive cannot drift as the
+      # surrounding code changes and needs no closing boundary.
+      #
+      # @safety
+      #   The autocorrection is unsafe because the suppression scope shrinks
+      #   from the whole region to the statement: offenses of the suppressed
+      #   cops located on the directive lines themselves resurface.
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable Metrics/AbcSize
+      #   def foo
+      #   end
+      #   # rubocop:enable Metrics/AbcSize
+      #
+      #   # good
+      #   # rubocop:disable-next Metrics/AbcSize
+      #   def foo
+      #   end
+      #
+      #   # bad
+      #   # rubocop:push -Metrics/AbcSize
+      #   def foo
+      #   end
+      #   # rubocop:pop
+      #
+      #   # good
+      #   # rubocop:disable-next Metrics/AbcSize
+      #   def foo
+      #   end
+      #
+      #   # good - the region spans more than one statement
+      #   # rubocop:disable Metrics/AbcSize
+      #   def foo
+      #   end
+      #
+      #   def bar
+      #   end
+      #   # rubocop:enable Metrics/AbcSize
+      #
+      class DirectiveScope < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_PAIR = 'Use `%<mode>s-next` instead of a `%<mode>s`/`enable` pair ' \
+                   'around a single statement.'
+        MSG_PUSH_POP = 'Use `disable-next` instead of `push`/`pop` around a single statement.'
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            directive = DirectiveComment.new(comment)
+            next unless comment_config.comment_only_line?(directive.line_number)
+
+            if plain_disable?(directive)
+              check_pair(directive)
+            elsif disable_only_push?(directive)
+              check_push_pop(directive)
+            end
+          end
+        end
+
+        private
+
+        def comment_config
+          processed_source.comment_config
+        end
+
+        def plain_disable?(directive)
+          directive.disabled? && !directive.disable_next?
+        end
+
+        def disable_only_push?(directive)
+          directive.push? && !directive.push_args.empty? && directive.push_args.keys == ['-']
+        end
+
+        def check_pair(directive)
+          enable = single_statement_closing_directive(directive)
+          return unless enable&.enabled?
+          return unless enable.raw_cop_names.sort == directive.raw_cop_names.sort
+
+          message = format(MSG_PAIR, mode: directive.mode)
+          add_offense(directive.comment, message: message) do |corrector|
+            convert_pair(corrector, directive, enable)
+          end
+        end
+
+        def convert_pair(corrector, directive, enable)
+          replacement = directive.comment.text.sub(/\b#{directive.mode}\b/,
+                                                   "#{directive.mode}-next")
+          corrector.replace(directive.comment, replacement)
+          remove_line(corrector, enable.comment)
+        end
+
+        def check_push_pop(directive)
+          pop = single_statement_closing_directive(directive)
+          return unless pop&.pop?
+
+          add_offense(directive.comment, message: MSG_PUSH_POP) do |corrector|
+            corrector.replace(directive.comment, disable_next_replacement(directive))
+            remove_line(corrector, pop.comment)
+          end
+        end
+
+        # The directive closing this one's scope, when that scope wraps
+        # exactly one statement - `nil` otherwise.
+        def single_statement_closing_directive(directive)
+          closing_line = single_closing_line(directive)
+          return nil unless closing_line
+
+          closing_comment = processed_source.comment_at_line(closing_line)
+          return nil unless closing_comment
+          return nil unless wraps_single_statement?(directive, closing_line)
+
+          DirectiveComment.new(closing_comment)
+        end
+
+        # The single line on which every disabled range opened by this
+        # directive ends, or `nil` when the ranges disagree or never close.
+        # For a `disable` that is the `enable` line; for a `push` it is the
+        # line before the `pop`.
+        def single_closing_line(directive)
+          ranges = ranges_opened_by(directive)
+          return nil if ranges.empty?
+
+          ends = ranges.map(&:end).uniq
+          return nil unless ends.size == 1 && ends.first.to_f.finite?
+
+          directive.push? ? ends.first + 1 : ends.first
+        end
+
+        def ranges_opened_by(directive)
+          comment_config.cop_disabled_line_ranges.each_value.flat_map do |ranges|
+            ranges.select do |range|
+              range.respond_to?(:directive) && range.directive.comment.equal?(directive.comment)
+            end
+          end
+        end
+
+        # The region wraps a single statement only when the directive sits
+        # immediately above it and the closing directive immediately below -
+        # any other line inside the region (a comment, a blank line) may
+        # carry offenses of the suppressed cops that the tighter scope
+        # would no longer cover.
+        def wraps_single_statement?(directive, closing_line)
+          scope = comment_config.statement_scope_after(directive.line_number)
+
+          !scope.nil? && scope.begin == directive.line_number + 1 && scope.end + 1 == closing_line
+        end
+
+        def disable_next_replacement(directive)
+          cops = directive.push_args['-'].join(', ')
+          reason = directive.reason
+          text = "# rubocop:disable-next #{cops}"
+          reason ? "#{text} -- #{reason}" : text
+        end
+
+        def remove_line(corrector, comment)
+          corrector.remove(range_by_whole_lines(comment.source_range, include_final_newline: true))
+        end
+      end
+    end
+  end
+end

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

@@ -6,12 +6,29 @@ module RuboCop
   module Cop
     module Style
       # Detects comments to enable/disable RuboCop.
-      # This is useful if want to make sure that every RuboCop error gets fixed
+      # This is useful if you want to make sure that every RuboCop error gets fixed
       # and not quickly disabled with a comment.
       #
       # 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.
+      #
+      # With `AllowTrailingComment` set to `true`, a disable directive carrying
+      # a `--` trailing justification comment is allowed, so a team can require
+      # every disable to be documented instead of banning them outright. Enable
+      # directives are not checked in this mode, since they end a suppression
+      # rather than start one.
+      #
+      # 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,17 +47,40 @@ 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
+      #
+      # @example AllowTrailingComment: true
+      #   # bad
+      #   x = 0 # rubocop:disable Layout/SpaceAroundOperators
+      #
+      #   # good
+      #   x = 0 # rubocop:disable Layout/SpaceAroundOperators -- would misalign the table
+      #
       class DisableCopsWithinSourceCodeDirective < Base
         extend AutoCorrector
 
         # rubocop:enable Lint/RedundantCopDisableDirective
         MSG = 'RuboCop disable/enable directives are not permitted.'
         MSG_FOR_COPS = 'RuboCop disable/enable directives for %<cops>s are not permitted.'
+        MSG_MISSING_REASON = 'RuboCop disable directives without a `--` justification ' \
+                             'comment are not permitted.'
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            directive_cops = directive_cops(comment)
-            disallowed_cops = directive_cops - allowed_cops
+            directive = DirectiveComment.new(comment)
+            next if allow_trailing_comment? && (directive.reason || directive.enabled?)
+
+            directive_cops = directive_cops(directive)
+            disallowed_cops = compute_disallowed_cops(directive_cops)
 
             next unless disallowed_cops.any?
 
@@ -50,14 +90,20 @@ module RuboCop
 
         private
 
-        def register_offense(comment, directive_cops, disallowed_cops)
-          message = if any_cops_allowed?
-                      format(MSG_FOR_COPS, cops: "`#{disallowed_cops.join('`, `')}`")
-                    else
-                      MSG
-                    end
+        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
 
-          add_offense(comment, message: message) do |corrector|
+        def register_offense(comment, directive_cops, disallowed_cops)
+          add_offense(comment, message: offense_message(disallowed_cops)) do |corrector|
             replacement = ''
 
             if directive_cops.length != disallowed_cops.length
@@ -69,18 +115,36 @@ module RuboCop
           end
         end
 
-        def directive_cops(comment)
-          match_captures = DirectiveComment.new(comment).match_captures
+        def offense_message(disallowed_cops)
+          if allow_trailing_comment?
+            MSG_MISSING_REASON
+          elsif any_cops_allowed? || disallowed_cops_config.any?
+            format(MSG_FOR_COPS, cops: "`#{disallowed_cops.join('`, `')}`")
+          else
+            MSG
+          end
+        end
+
+        def directive_cops(directive)
+          match_captures = directive.match_captures
           match_captures && match_captures[1] ? match_captures[1].split(',').map(&:strip) : []
         end
 
+        def allow_trailing_comment?
+          cop_config['AllowTrailingComment']
+        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/document_dynamic_eval_definition.rb

@@ -161,7 +161,12 @@ module RuboCop
           source = source.gsub(COMMENT_REGEXP, '')
           return if source.blank?
 
-          /\s*#{Regexp.escape(source.strip)}/
+          # Treat `\#` (an escaped interpolation marker in the heredoc) as matching
+          # either `\#` or `#` in the comment, since the comment may show either
+          # the literal source form or the runtime appearance.
+          segments = source.strip.split('\\#', -1).map { |segment| Regexp.escape(segment) }
+
+          /\s*#{segments.join('\\\\?#')}/
         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
@@ -29,52 +34,57 @@ module RuboCop
       #   end
       #
       #   # allowed
-      #     # Class without body
+      #   # Class without body
+      #   class Person
+      #   end
+      #
+      #   # Namespace - A namespace can be a class or a module
+      #   # Containing a class
+      #   module Namespace
+      #     # Description/Explanation of Person class
       #     class Person
+      #       # ...
       #     end
+      #   end
       #
-      #     # Namespace - A namespace can be a class or a module
-      #     # Containing a class
-      #     module Namespace
-      #       # Description/Explanation of Person class
-      #       class Person
-      #         # ...
-      #       end
+      #   # Containing constant visibility declaration
+      #   module Namespace
+      #     class Private
       #     end
       #
-      #     # Containing constant visibility declaration
-      #     module Namespace
-      #       class Private
-      #       end
-      #
-      #       private_constant :Private
-      #     end
+      #     private_constant :Private
+      #   end
       #
-      #     # Containing constant definition
-      #     module Namespace
-      #       Public = Class.new
-      #     end
+      #   # Containing constant definition
+      #   module Namespace
+      #     Public = Class.new
+      #   end
       #
-      #     # Macro calls
-      #     module Namespace
-      #       extend Foo
-      #     end
+      #   # Macro calls
+      #   module Namespace
+      #     extend Foo
+      #   end
       #
       # @example AllowedConstants: ['ClassMethods']
       #
-      #    # good
-      #    module A
-      #      module ClassMethods
-      #        # ...
-      #      end
+      #   # good
+      #   module A
+      #     module ClassMethods
+      #       # ...
       #     end
+      #   end
       #
       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))
@@ -186,7 +233,7 @@ module RuboCop
         def qualify_const(node)
           return if node.nil?
 
-          if node.cbase_type? || node.self_type? || node.call_type? || node.variable?
+          if node.type?(:cbase, :self, :call) || node.variable?
             node.source
           else
             [qualify_const(node.namespace), node.short_name].compact

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

@@ -95,6 +95,17 @@ module RuboCop
       #     end
       #   end
       #
+      # @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
+      #
       class DocumentationMethod < Base
         include DocumentationComment
         include DefNode
@@ -119,6 +130,7 @@ module RuboCop
         def check(node)
           return if non_public?(node) && !require_for_non_public_methods?
           return if documentation_comment?(node)
+          return if method_allowed?(node)
 
           add_offense(node)
         end
@@ -126,6 +138,18 @@ module RuboCop
         def require_for_non_public_methods?
           cop_config['RequireForNonPublicMethods']
         end
+
+        def method_allowed?(node)
+          # For a modifier form like `module_function def foo; end`, `node` is the
+          # `module_function`/`ruby2_keywords` send; the real method name is on its
+          # `def`/`defs` argument, not the modifier itself.
+          method_name = node.send_type? ? node.first_argument.method_name : node.method_name
+          allowed_methods.include?(method_name)
+        end
+
+        def allowed_methods
+          @allowed_methods ||= cop_config.fetch('AllowedMethods', []).map(&:to_sym)
+        end
       end
     end
   end