rubocop 1.53.0 → 1.90.0

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

@@ -37,25 +37,20 @@ module RuboCop
         private
 
         def valid_context?(node)
-          unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
-            return true
-          end
-          return true if first_argument_block_type?(node.first_argument)
+          return true unless node.arguments.one? && node.first_argument.parenthesized_call?
+          return true if node.first_argument.any_block_type?
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
             valid_first_argument?(node.first_argument)
         end
 
-        def first_argument_block_type?(first_arg)
-          first_arg.block_type? || first_arg.numblock_type?
-        end
-
         def valid_first_argument?(first_arg)
-          first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg)
+          first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg) ||
+            compound_range?(first_arg)
         end
 
-        def first_argument_starts_with_left_parenthesis?(node)
-          node.first_argument.source.start_with?('(')
+        def compound_range?(first_arg)
+          first_arg.range_type? && first_arg.parenthesized_call?
         end
 
         def chained_calls?(node)
@@ -68,19 +63,9 @@ module RuboCop
         end
 
         def spaces_before_left_parenthesis(node)
-          receiver = node.receiver
-          receiver_length = if receiver
-                              receiver.source.length
-                            else
-                              0
-                            end
-          without_receiver = node.source[receiver_length..]
-
-          # Escape question mark if any.
-          method_regexp = Regexp.escape(node.method_name)
-
-          match = without_receiver.match(/^\s*&?\.?\s*#{method_regexp}(\s+)\(/)
-          match ? match.captures[0].length : 0
+          return 0 if node.parenthesized? || !node.first_argument.source.start_with?('(')
+
+          node.first_argument.source_range.begin_pos - node.loc.selector.end_pos
         end
 
         def space_range(expr, space_length)

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

@@ -22,13 +22,9 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   %w('foo', "bar")
       #
-      # @example
-      #
       #   # good
-      #
       #   %w(foo bar)
       class PercentStringArray < Base
         include PercentLiteral

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

@@ -12,13 +12,9 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   %i(:foo, :bar)
       #
-      # @example
-      #
       #   # good
-      #
       #   %i(foo bar)
       class PercentSymbolArray < Base
         include PercentLiteral

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

@@ -3,15 +3,18 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for `raise` or `fail` statements which are
-      # raising `Exception` class.
+      # Checks for `raise` or `fail` statements which raise `Exception` or
+      # `Exception.new`. Use `StandardError` or a specific exception class instead.
       #
-      # You can specify a module name that will be an implicit namespace
-      # using `AllowedImplicitNamespaces` option. The cop cause a false positive
-      # for namespaced `Exception` when a namespace is omitted. This option can
-      # prevent the false positive by specifying a namespace to be omitted for
-      # `Exception`. Alternatively, make `Exception` a fully qualified class
-      # name with an explicit namespace.
+      # If you have defined your own namespaced `Exception` class, it is possible
+      # to configure the cop to allow it by setting `AllowedImplicitNamespaces` to
+      # an array with the names of the namespaces to allow. By default, this is set to
+      # `['Gem']`, which allows `Gem::Exception` to be raised without an explicit namespace.
+      # If not allowed, a false positive may be registered if `raise Exception` is called
+      # within the namespace.
+      #
+      # Alternatively, use a fully qualified name with `raise`/`fail`
+      # (eg. `raise Namespace::Exception`).
       #
       # @safety
       #   This cop is unsafe because it will change the exception class being
@@ -20,15 +23,31 @@ module RuboCop
       # @example
       #   # bad
       #   raise Exception, 'Error message here'
+      #   raise Exception.new('Error message here')
       #
       #   # good
       #   raise StandardError, 'Error message here'
+      #   raise MyError.new, 'Error message here'
+      #
+      # @example AllowedImplicitNamespaces: ['Gem'] (default)
+      #   # bad - `Foo` is not an allowed implicit namespace
+      #   module Foo
+      #     def self.foo
+      #       raise Exception # This is qualified to `Foo::Exception`.
+      #     end
+      #   end
       #
-      # @example AllowedImplicitNamespaces: ['Gem']
       #   # good
       #   module Gem
       #     def self.foo
-      #       raise Exception # This exception means `Gem::Exception`.
+      #       raise Exception # This is qualified to `Gem::Exception`.
+      #     end
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     def self.foo
+      #       raise Foo::Exception
       #     end
       #   end
       class RaiseException < Base
@@ -76,7 +95,7 @@ module RuboCop
           if parent.module_type?
             namespace = parent.identifier.source
 
-            return allow_implicit_namespaces.include?(namespace)
+            return true if allow_implicit_namespaces.include?(namespace)
           end
 
           implicit_namespace?(parent)

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

@@ -4,21 +4,17 @@ module RuboCop
   module Cop
     module Lint
       # Checks for `rand(1)` calls.
-      # Such calls always return `0`.
+      # Such calls always return `0`, and so do `rand(-1)`, `rand(1.0)`, and `rand(-1.0)`.
       #
       # @example
       #
       #   # bad
-      #
       #   rand 1
       #   Kernel.rand(-1)
       #   rand 1.0
       #   rand(-1.0)
       #
-      # @example
-      #
       #   # good
-      #
       #   0 # just use 0 instead
       class RandOne < Base
         MSG = '`%<method>s` always returns `0`. Perhaps you meant `rand(2)` or `rand`?'

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

@@ -2,7 +2,7 @@
 
 # The Lint/RedundantCopDisableDirective cop needs to be disabled so as
 # to be able to provide a (bad) example of a redundant disable.
-# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -104,31 +104,81 @@ module RuboCop
         end
 
         def each_redundant_disable(&block)
+          each_detached_next_directive(&block)
+
           cop_disabled_line_ranges.each do |cop, line_ranges|
+            # A pending cop that is not enabled in this run produces no
+            # offenses, so its directives cannot be judged - they typically
+            # prepare the code for the moment the cop gets enabled.
+            next if pending_cop_not_run?(cop)
+
             each_already_disabled(cop, line_ranges, &block)
             each_line_range(cop, line_ranges, &block)
           end
         end
 
+        def pending_cop_not_run?(cop)
+          # `Config#for_cop` corrects wrongly-namespaced names, but a name that
+          # is not registered as written never suppresses anything, so it is
+          # reported as unknown rather than exempted via the corrected cop.
+          return false unless all_cop_names.include?(cop)
+
+          cop_cfg = config.for_cop(cop)
+          cop_cfg['Enabled'] == 'pending' &&
+            !processed_source.registry.enabled_pending_cop?(cop_cfg, config, cop)
+        end
+
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
-            next if ignore_offense?(line_range)
-            next if expected_final_disable?(cop, line_range)
-
-            comment = processed_source.comment_at_line(line_range.begin)
-            redundant = if all_disabled?(comment)
-                          find_redundant_all(line_range, line_ranges[line_range_index + 1])
-                        elsif department_disabled?(cop, comment)
-                          find_redundant_department(cop, line_range)
-                        else
-                          find_redundant_cop(cop, line_range)
-                        end
+            next if should_skip_line_range?(cop, line_range)
+
+            comment = directive_comment(line_range)
+            next if skip_directive?(comment)
 
+            next_range = line_ranges[line_range_index + 1]
+            redundant = find_redundant_directive(cop, comment, line_range, next_range)
             yield comment, redundant if redundant
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def should_skip_line_range?(cop, line_range)
+          ignore_offense?(line_range) || expected_final_disable?(cop, line_range)
+        end
+
+        # A range opened by a `disable-next` directive starts at the statement,
+        # not at the directive comment above it, so ask the range itself.
+        def directive_comment(line_range)
+          if line_range.respond_to?(:directive)
+            line_range.directive.comment
+          else
+            processed_source.comment_at_line(line_range.begin)
+          end
+        end
+
+        # A `disable-next` with no statement attached (or misplaced at the end
+        # of a code line) suppresses nothing, so it is redundant by definition.
+        def each_detached_next_directive
+          processed_source.comment_config.detached_next_directives.each do |directive|
+            directive.raw_cop_names.each { |cop| yield directive.comment, cop }
+          end
+        end
+
+        def skip_directive?(comment)
+          directive = DirectiveComment.new(comment)
+          directive.push? || directive.pop?
+        end
+
+        def find_redundant_directive(cop, comment, line_range, next_range)
+          if all_disabled?(comment)
+            find_redundant_all(line_range, next_range)
+          elsif department_disabled?(cop, comment)
+            find_redundant_department(cop, line_range)
+          else
+            find_redundant_cop(cop, line_range)
+          end
+        end
+
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
             next if ignore_offense?(range)
@@ -138,7 +188,7 @@ module RuboCop
             # whether there are offenses or not.
             next unless followed_ranges?(previous_range, range)
 
-            comment = processed_source.comment_at_line(range.begin)
+            comment = directive_comment(range)
 
             next unless comment
             # Comments disabling all cops don't count since it's reasonable
@@ -156,7 +206,6 @@ module RuboCop
             yield comment, redundant if redundant
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def find_redundant_cop(cop, range)
           cop_offenses = offenses_to_check.select { |offense| offense.cop_name == cop }
@@ -184,7 +233,11 @@ module RuboCop
         end
 
         def range_with_offense?(range, offenses = offenses_to_check)
-          offenses.none? { |offense| range.cover?(offense.line) }
+          # An offense is covered when the disabled range overlaps any line of
+          # its span, mirroring how offenses are suppressed.
+          offenses.none? do |offense|
+            offense.line <= range.end && offense.location.last_line >= range.begin
+          end
         end
 
         def all_disabled?(comment)
@@ -230,14 +283,28 @@ module RuboCop
           location = DirectiveComment.new(comment).range
           cop_names = cops.sort.map { |c| describe(c) }.join(', ')
 
+          # An unknown cop may just not be loaded in this run (e.g. a custom
+          # cop whose configuration failed to load) - removing its directive
+          # would destroy something that cannot be restored, so only report.
+          # A misplaced EOL `disable-next` should be moved, not deleted.
+          if any_unknown_cop?(cops) || misplaced_next_directive?(comment)
+            return add_offense(location, message: message(cop_names))
+          end
+
           add_offense(location, message: message(cop_names)) do |corrector|
-            range = comment_range_with_surrounding_space(location, comment.source_range)
+            remove_entire_comment(corrector, comment)
+          end
+        end
 
-            if leave_free_comment?(comment, range)
-              corrector.replace(range, ' # ')
-            else
-              corrector.remove(range)
-            end
+        def remove_entire_comment(corrector, comment)
+          # Take the `--` reason with the directive; `leave_free_comment?` keeps anything else.
+          directive_range = DirectiveComment.new(comment).range_with_reason
+          range = comment_range_with_surrounding_space(directive_range, comment.source_range)
+
+          if leave_free_comment?(comment, range)
+            corrector.replace(range, ' # ')
+          else
+            corrector.remove(range)
           end
         end
 
@@ -247,14 +314,35 @@ module RuboCop
           ranges = cop_ranges.map { |_, r| r }
 
           cop_ranges.each do |cop, range|
-            cop_name = describe(cop)
-            add_offense(range, message: message(cop_name)) do |corrector|
-              range = directive_range_in_list(range, ranges)
-              corrector.remove(range)
-            end
+            add_offense_for_cop_in_list(cop, range, ranges)
+          end
+        end
+
+        def add_offense_for_cop_in_list(cop, range, ranges)
+          cop_name = describe(cop)
+          return add_offense(range, message: message(cop_name)) if unknown_cop?(cop)
+
+          add_offense(range, message: message(cop_name)) do |corrector|
+            corrector.remove(directive_range_in_list(range, ranges))
           end
         end
 
+        def any_unknown_cop?(cops)
+          cops.any? { |cop| unknown_cop?(cop) }
+        end
+
+        def misplaced_next_directive?(comment)
+          directive = DirectiveComment.new(comment)
+          directive.disable_next? &&
+            !processed_source.comment_config.comment_only_line?(directive.line_number)
+        end
+
+        def unknown_cop?(cop)
+          return false if cop == 'all' || department_marker?(cop)
+
+          !all_cop_names.include?(cop)
+        end
+
         def leave_free_comment?(comment, range)
           free_comment = comment.text.gsub(range.source.strip, '')
 
@@ -269,7 +357,10 @@ module RuboCop
         end
 
         def matching_range(haystack, needle)
-          offset = haystack.source.index(needle)
+          # Match the cop name as a whole token so a shorter name is not found inside a
+          # longer one that shares its prefix (e.g. `Lint/AmbiguousOperator` in
+          # `Lint/AmbiguousOperatorPrecedence`).
+          offset = haystack.source.index(/#{Regexp.escape(needle)}(?!\w)/)
           return unless offset
 
           offset += haystack.begin_pos
@@ -286,7 +377,13 @@ module RuboCop
 
         SIMILAR_COP_NAMES_CACHE = Hash.new do |hash, cop_name|
           hash[:all_cop_names] = Registry.global.names unless hash.key?(:all_cop_names)
-          hash[cop_name] = NameSimilarity.find_similar_name(cop_name, hash[:all_cop_names])
+          # A registered cop with the same base name is a better suggestion
+          # than anything spelling similarity can find - the most common
+          # mistake is qualifying a cop with the wrong department.
+          basename = "/#{cop_name.split('/').last}"
+          same_basename = hash[:all_cop_names].find { |name| name.end_with?(basename) }
+          hash[cop_name] =
+            same_basename || NameSimilarity.find_similar_name(cop_name, hash[:all_cop_names])
         end
         private_constant :SIMILAR_COP_NAMES_CACHE
 
@@ -327,4 +424,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective

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

@@ -1,27 +1,23 @@
 # frozen_string_literal: true
 
-# The Lint/RedundantCopEnableDirective and Lint/RedundantCopDisableDirective
-# cops need to be disabled so as to be able to provide a (bad) example of an
-# unneeded enable.
-
-# rubocop:disable Lint/RedundantCopEnableDirective
-# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
       # Detects instances of rubocop:enable comments that can be
       # removed.
       #
-      # When comment enables all cops at once `rubocop:enable all`
-      # that cop checks whether any cop was actually enabled.
+      # When a comment enables all cops at once `rubocop:enable all`
+      # the cop checks whether any cop was actually enabled.
+      #
       # @example
+      #
       #   # bad
       #   foo = 1
       #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   foo = 1
-      # @example
+      #
       #   # bad
       #   # rubocop:disable Style/StringLiterals
       #   foo = "1"
@@ -34,21 +30,55 @@ module RuboCop
       #   foo = "1"
       #   # rubocop:enable all
       #   baz
+      #
+      #   # bad
+      #   foo = 1
+      #   # rubocop:pop
+      #
+      #   # good
+      #   # rubocop:push -Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:pop
       class RedundantCopEnableDirective < Base
         include RangeHelp
         include SurroundingSpace
         extend AutoCorrector
 
         MSG = 'Unnecessary enabling of %<cop>s.'
+        MSG_ORPHAN_POP = 'Unnecessary `rubocop:pop` without a matching `rubocop:push`.'
 
         def on_new_investigation
-          return if processed_source.blank? || !processed_source.raw_source.include?('enable')
+          return if processed_source.blank?
 
+          source = processed_source.raw_source
+          check_extra_enables if source.include?('enable')
+          check_orphan_pops if source.include?('pop')
+        end
+
+        private
+
+        def check_extra_enables
           offenses = processed_source.comment_config.extra_enabled_comments
           offenses.each { |comment, cop_names| register_offense(comment, cop_names) }
         end
 
-        private
+        def check_orphan_pops
+          push_depth = 0
+          processed_source.comments.each do |comment|
+            directive = DirectiveComment.new(comment)
+            if directive.push?
+              push_depth += 1
+            elsif directive.pop?
+              push_depth.zero? ? register_orphan_pop(directive) : push_depth -= 1
+            end
+          end
+        end
+
+        def register_orphan_pop(directive)
+          add_offense(directive.range, message: MSG_ORPHAN_POP) do |corrector|
+            corrector.remove(range_with_surrounding_space(directive.range, side: :right))
+          end
+        end
 
         def register_offense(comment, cop_names)
           directive = DirectiveComment.new(comment)
@@ -59,15 +89,21 @@ module RuboCop
               range_of_offense(comment, name),
               message: format(MSG, cop: all_or_name(name))
             ) do |corrector|
-              if directive.match?(cop_names)
-                corrector.remove(range_with_surrounding_space(directive.range, side: :right))
-              else
-                corrector.remove(range_with_comma(comment, name))
-              end
+              corrector.remove(removal_range(directive, comment, cop_names, name))
             end
           end
         end
 
+        # When every cop on the directive is redundant the whole comment goes, `--` reason
+        # included; otherwise just the one cop is spliced out of the list.
+        def removal_range(directive, comment, cop_names, name)
+          if directive.match?(cop_names)
+            range_with_surrounding_space(directive.range_with_reason, side: :right)
+          else
+            range_with_comma(comment, name)
+          end
+        end
+
         def range_of_offense(comment, name)
           start_pos = comment_start(comment) + cop_name_indention(comment, name)
           range_between(start_pos, start_pos + name.size)
@@ -78,7 +114,10 @@ module RuboCop
         end
 
         def cop_name_indention(comment, name)
-          comment.text.index(name)
+          # Match the cop name as a whole token so a shorter name is not found inside a
+          # longer one that shares its prefix (e.g. `Layout/EmptyLines` in
+          # `Layout/EmptyLinesAfterModuleInclusion`).
+          comment.text.index(/#{Regexp.escape(name)}(?!\w)/)
         end
 
         def range_with_comma(comment, name)
@@ -109,7 +148,7 @@ module RuboCop
           range_between(start + begin_pos - 1, start + end_pos)
         end
 
-        # If the list of cops is comma-separated, but without a empty space after the comma,
+        # If the list of cops is comma-separated, but without an empty space after the comma,
         # we should **not** remove the prepending empty space, thus begin_pos += 1
         def range_with_comma_after(comment, start, begin_pos, end_pos)
           begin_pos += 1 if comment.source[end_pos + 1] != ' '
@@ -128,6 +167,3 @@ module RuboCop
     end
   end
 end
-
-# rubocop:enable Lint/RedundantCopDisableDirective
-# rubocop:enable Lint/RedundantCopEnableDirective

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

@@ -38,10 +38,10 @@ module RuboCop
         GLOB_METHODS = %i[glob []].freeze
 
         def on_send(node)
-          return unless (receiver = node.receiver)
-          return unless receiver.receiver&.const_type? && receiver.receiver.short_name == :Dir
-          return unless GLOB_METHODS.include?(receiver.method_name)
-          return if multiple_argument?(receiver)
+          return unless dir_glob?(node.receiver)
+          # `sort` with a comparator block or block-pass changes the order, so it is
+          # not redundant with the default sorting performed by `Dir.glob`/`Dir[]`.
+          return if sort_with_comparator?(node) || multiple_argument?(node.receiver)
 
           selector = node.loc.selector
 
@@ -53,9 +53,20 @@ module RuboCop
 
         private
 
+        def dir_glob?(receiver)
+          return false unless receiver&.receiver&.const_type?
+          return false unless receiver.receiver.short_name == :Dir
+
+          GLOB_METHODS.include?(receiver.method_name)
+        end
+
         def multiple_argument?(glob_method)
           glob_method.arguments.count >= 2 || glob_method.first_argument&.splat_type?
         end
+
+        def sort_with_comparator?(node)
+          node.parent&.any_block_type? || node.last_argument&.block_pass_type?
+        end
       end
     end
   end

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

@@ -3,7 +3,15 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for redundant quantifiers inside Regexp literals.
+      # Checks for redundant quantifiers inside `Regexp` literals.
+      #
+      # It is always allowed when interpolation is used in a regexp literal,
+      # because it's unknown what kind of string will be expanded as a result:
+      #
+      # [source,ruby]
+      # ----
+      # /(?:a*#{interpolation})?/x
+      # ----
       #
       # @example
       #   # bad
@@ -32,6 +40,8 @@ module RuboCop
                                    'with a single `%<replacement>s`.'
 
         def on_regexp(node)
+          return if node.interpolation?
+
           each_redundantly_quantified_pair(node) do |group, child|
             replacement = merged_quantifier(group, child)
             add_offense(
@@ -63,7 +73,7 @@ module RuboCop
         end
 
         def redundant_group?(expr)
-          expr.is?(:passive, :group) && expr.count { |child| child.type != :free_space } == 1
+          expr.is?(:passive, :group) && expr.one? { |child| child.type != :free_space }
         end
 
         def redundantly_quantifiable?(node)