rubocop 1.24.1 → 1.64.1

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

@@ -19,7 +19,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = '`(...)` interpreted as grouped expression.'
+        MSG = '`%<argument>s` interpreted as grouped expression.'
 
         def on_send(node)
           return if valid_context?(node)
@@ -28,8 +28,9 @@ module RuboCop
           return unless space_length.positive?
 
           range = space_range(node.first_argument.source_range, space_length)
+          message = format(MSG, argument: node.first_argument.source)
 
-          add_offense(range) { |corrector| corrector.remove(range) }
+          add_offense(range, message: message) { |corrector| corrector.remove(range) }
         end
         alias on_csend on_send
 
@@ -39,11 +40,16 @@ module RuboCop
           unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
             return true
           end
+          return true if first_argument_block_type?(node.first_argument)
 
           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)
         end
@@ -54,7 +60,7 @@ module RuboCop
 
         def chained_calls?(node)
           first_argument = node.first_argument
-          first_argument.send_type? && (node.children.last&.children&.count || 0) > 1
+          first_argument.call_type? && (node.children.last&.children&.count || 0) > 1
         end
 
         def ternary_expression?(node)
@@ -68,7 +74,7 @@ module RuboCop
                             else
                               0
                             end
-          without_receiver = node.source[receiver_length..-1]
+          without_receiver = node.source[receiver_length..]
 
           # Escape question mark if any.
           method_regexp = Regexp.escape(node.method_name)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for quotes and commas in %w, e.g. `%w('foo', "bar")`
+      # Checks for quotes and commas in %w, e.g. `%w('foo', "bar")`
       #
       # It is more likely that the additional characters are unintended (for
       # example, mistranslating an array of literals to percent string notation)
@@ -50,7 +50,7 @@ module RuboCop
 
           add_offense(node) do |corrector|
             node.each_value do |value|
-              range = value.loc.expression
+              range = value.source_range
 
               match = range.source.match(TRAILING_QUOTE)
               corrector.remove_trailing(range, match[0].length) if match

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for colons and commas in %i, e.g. `%i(:foo, :bar)`
+      # Checks for colons and commas in %i, e.g. `%i(:foo, :bar)`
       #
       # It is more likely that the additional characters are unintended (for
       # example, mistranslating an array of literals to percent string notation)
@@ -41,7 +41,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           node.children.each do |child|
-            range = child.loc.expression
+            range = child.source_range
 
             corrector.remove_trailing(range, 1) if range.source.end_with?(',')
             corrector.remove_leading(range, 1) if

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for `raise` or `fail` statements which are
+      # Checks for `raise` or `fail` statements which are
       # raising `Exception` class.
       #
       # You can specify a module name that will be an implicit namespace
@@ -15,7 +15,7 @@ module RuboCop
       #
       # @safety
       #   This cop is unsafe because it will change the exception class being
-      #   raised, which is a change in behaviour.
+      #   raised, which is a change in behavior.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for `rand(1)` calls.
+      # Checks for `rand(1)` calls.
       # Such calls always return `0`.
       #
       # @example

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

@@ -6,7 +6,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop detects instances of rubocop:disable comments that can be
+      # Detects instances of rubocop:disable comments that can be
       # removed without causing any offenses to be reported. It's implemented
       # as a cop in that it inherits from the Cop base class and calls
       # add_offense. The unusual part of its implementation is that it doesn't
@@ -71,16 +71,16 @@ module RuboCop
              processed_source.comment_config.comment_only_line?(directive_comment_range.line) &&
              directive_comment_range.begin_pos == line_comment_range.begin_pos
             # When the previous line is blank, it should be retained
-            range_with_surrounding_space(range: directive_comment_range, side: :right)
+            range_with_surrounding_space(directive_comment_range, side: :right)
           else
             # Eat the entire comment, the preceding space, and the preceding
             # newline if there is one.
             original_begin = directive_comment_range.begin_pos
             range = range_with_surrounding_space(
-              range: directive_comment_range, side: :left, newlines: true
+              directive_comment_range, side: :left, newlines: true
             )
 
-            range_with_surrounding_space(range: range,
+            range_with_surrounding_space(range,
                                          side: :right,
                                          # Special for a comment that
                                          # begins the file: remove
@@ -94,13 +94,13 @@ module RuboCop
           # is NOT being removed?
           if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
             # Eat the comma on the left.
-            range = range_with_surrounding_space(range: range, side: :left)
+            range = range_with_surrounding_space(range, side: :left)
             range = range_with_surrounding_comma(range, :left)
           end
 
           range = range_with_surrounding_comma(range, :right)
           # Eat following spaces up to EOL, but not the newline itself.
-          range_with_surrounding_space(range: range, side: :right, newlines: false)
+          range_with_surrounding_space(range, side: :right, newlines: false)
         end
 
         def each_redundant_disable(&block)
@@ -113,6 +113,7 @@ module RuboCop
         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)
@@ -127,23 +128,35 @@ module RuboCop
           end
         end
 
+        # rubocop:disable 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)
-            next unless followed_ranges?(previous_range, range)
-
             # If a cop is disabled in a range that begins on the same line as
             # the end of the previous range, it means that the cop was
             # already disabled by an earlier comment. So it's redundant
             # whether there are offenses or not.
+            next unless followed_ranges?(previous_range, range)
+
             comment = processed_source.comment_at_line(range.begin)
 
+            next unless comment
             # Comments disabling all cops don't count since it's reasonable
             # to disable a few select cops first and then all cops further
             # down in the code.
-            yield comment, cop if comment && !all_disabled?(comment)
+            next if all_disabled?(comment)
+
+            redundant =
+              if department_disabled?(cop, comment)
+                find_redundant_department(cop, range)
+              else
+                cop
+              end
+
+            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 }
@@ -179,11 +192,21 @@ module RuboCop
         end
 
         def ignore_offense?(line_range)
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
           disabled_ranges.any? do |range|
             range.cover?(line_range.min) && range.cover?(line_range.max)
           end
         end
 
+        def expected_final_disable?(cop, line_range)
+          # A cop which is disabled in the config is being re-disabled until end of file
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          cop_class &&
+            !processed_source.registry.enabled?(cop_class, config) &&
+            line_range.max == Float::INFINITY
+        end
+
         def department_disabled?(cop, comment)
           directive = DirectiveComment.new(comment)
           directive.in_directive_department?(cop) && !directive.overridden_by_department?(cop)
@@ -208,8 +231,13 @@ module RuboCop
           cop_names = cops.sort.map { |c| describe(c) }.join(', ')
 
           add_offense(location, message: message(cop_names)) do |corrector|
-            range = comment_range_with_surrounding_space(location, comment.loc.expression)
-            corrector.remove(range)
+            range = comment_range_with_surrounding_space(location, comment.source_range)
+
+            if leave_free_comment?(comment, range)
+              corrector.replace(range, ' # ')
+            else
+              corrector.remove(range)
+            end
           end
         end
 
@@ -227,10 +255,16 @@ module RuboCop
           end
         end
 
+        def leave_free_comment?(comment, range)
+          free_comment = comment.text.gsub(range.source.strip, '')
+
+          !free_comment.empty? && !free_comment.start_with?('#')
+        end
+
         def cop_range(comment, cop)
           cop = remove_department_marker(cop)
-          matching_range(comment.loc.expression, cop) ||
-            matching_range(comment.loc.expression, Badge.parse(cop).cop_name) ||
+          matching_range(comment.source_range, cop) ||
+            matching_range(comment.source_range, Badge.parse(cop).cop_name) ||
             raise("Couldn't find #{cop} in comment: #{comment.text}")
         end
 
@@ -247,15 +281,21 @@ module RuboCop
             .drop_while { |r| !r.equal?(range) }
             .each_cons(2)
             .map { |range1, range2| range1.end.join(range2.begin).source }
-            .all? { |intervening| /\A\s*,\s*\Z/.match?(intervening) }
+            .all?(/\A\s*,\s*\z/)
+        end
+
+        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])
         end
+        private_constant :SIMILAR_COP_NAMES_CACHE
 
         def describe(cop)
           return 'all cops' if cop == 'all'
           return "`#{remove_department_marker(cop)}` department" if department_marker?(cop)
           return "`#{cop}`" if all_cop_names.include?(cop)
 
-          similar = NameSimilarity.find_similar_name(cop, all_cop_names)
+          similar = SIMILAR_COP_NAMES_CACHE[cop]
           similar ? "`#{cop}` (did you mean `#{similar}`?)" : "`#{cop}` (unknown cop)"
         end
 

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

@@ -9,7 +9,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop detects instances of rubocop:enable comments that can be
+      # Detects instances of rubocop:enable comments that can be
       # removed.
       #
       # When comment enables all cops at once `rubocop:enable all`
@@ -42,7 +42,7 @@ module RuboCop
         MSG = 'Unnecessary enabling of %<cop>s.'
 
         def on_new_investigation
-          return if processed_source.blank?
+          return if processed_source.blank? || !processed_source.raw_source.include?('enable')
 
           offenses = processed_source.comment_config.extra_enabled_comments
           offenses.each { |comment, cop_names| register_offense(comment, cop_names) }
@@ -60,7 +60,7 @@ module RuboCop
               message: format(MSG, cop: all_or_name(name))
             ) do |corrector|
               if directive.match?(cop_names)
-                corrector.remove(range_with_surrounding_space(range: directive.range, side: :right))
+                corrector.remove(range_with_surrounding_space(directive.range, side: :right))
               else
                 corrector.remove(range_with_comma(comment, name))
               end
@@ -74,7 +74,7 @@ module RuboCop
         end
 
         def comment_start(comment)
-          comment.loc.expression.begin_pos
+          comment.source_range.begin_pos
         end
 
         def cop_name_indention(comment, name)
@@ -82,7 +82,7 @@ module RuboCop
         end
 
         def range_with_comma(comment, name)
-          source = comment.loc.expression.source
+          source = comment.source
 
           begin_pos = cop_name_indention(comment, name)
           end_pos = begin_pos + name.size
@@ -94,14 +94,14 @@ module RuboCop
 
         def range_to_remove(begin_pos, end_pos, comment)
           start = comment_start(comment)
-          source = comment.loc.expression.source
+          source = comment.source
 
           if source[begin_pos - 1] == ','
             range_with_comma_before(start, begin_pos, end_pos)
           elsif source[end_pos] == ','
             range_with_comma_after(comment, start, begin_pos, end_pos)
           else
-            range_between(start, comment.loc.expression.end_pos)
+            range_between(start, comment.source_range.end_pos)
           end
         end
 
@@ -112,7 +112,7 @@ module RuboCop
         # If the list of cops is comma-separated, but without a 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.loc.expression.source[end_pos + 1] != ' '
+          begin_pos += 1 if comment.source[end_pos + 1] != ' '
 
           range_between(start + begin_pos, start + end_pos + 1)
         end

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

@@ -6,6 +6,11 @@ module RuboCop
       # Sort globbed results by default in Ruby 3.0.
       # This cop checks for redundant `sort` method to `Dir.glob` and `Dir[]`.
       #
+      # @safety
+      #   This cop is unsafe, in case of having a file and a directory with
+      #   identical names, since directory will be loaded before the file, which
+      #   will break `exe/files.rb` that rely on `exe.rb` file.
+      #
       # @example
       #
       #   # bad
@@ -36,6 +41,7 @@ module RuboCop
           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)
 
           selector = node.loc.selector
 
@@ -44,6 +50,12 @@ module RuboCop
             corrector.remove(node.loc.dot)
           end
         end
+
+        private
+
+        def multiple_argument?(glob_method)
+          glob_method.arguments.count >= 2 || glob_method.first_argument&.splat_type?
+        end
       end
     end
   end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # 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
+      #   /(?:x+)+/
+      #
+      #   # good
+      #   /(?:x)+/
+      #
+      #   # good
+      #   /(?:x+)/
+      #
+      #   # bad
+      #   /(?:x+)?/
+      #
+      #   # good
+      #   /(?:x)*/
+      #
+      #   # good
+      #   /(?:x*)/
+      class RedundantRegexpQuantifiers < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_REDUNDANT_QUANTIFIER = 'Replace redundant quantifiers ' \
+                                   '`%<inner_quantifier>s` and `%<outer_quantifier>s` ' \
+                                   '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(
+              quantifier_range(group, child),
+              message: message(group, child, replacement)
+            ) do |corrector|
+              # drop outer quantifier
+              corrector.replace(group.loc.quantifier, '')
+              # replace inner quantifier
+              corrector.replace(child.loc.quantifier, replacement)
+            end
+          end
+        end
+
+        private
+
+        def each_redundantly_quantified_pair(node)
+          seen = Set.new
+          node.parsed_tree&.each_expression do |(expr)|
+            next if seen.include?(expr) || !redundant_group?(expr) || !mergeable_quantifier(expr)
+
+            expr.each_expression do |(subexp)|
+              seen << subexp
+              break unless redundantly_quantifiable?(subexp)
+
+              yield(expr, subexp) if mergeable_quantifier(subexp)
+            end
+          end
+        end
+
+        def redundant_group?(expr)
+          expr.is?(:passive, :group) && expr.count { |child| child.type != :free_space } == 1
+        end
+
+        def redundantly_quantifiable?(node)
+          redundant_group?(node) || character_set?(node) || node.terminal?
+        end
+
+        def character_set?(expr)
+          expr.is?(:character, :set)
+        end
+
+        def mergeable_quantifier(expr)
+          # Merging reluctant or possessive quantifiers would be more complex,
+          # and Ruby does not emit warnings for these cases.
+          return unless expr.quantifier&.greedy?
+
+          # normalize quantifiers, e.g. "{1,}" => "+"
+          case expr.quantity
+          when [0, -1]
+            '*'
+          when [0, 1]
+            '?'
+          when [1, -1]
+            '+'
+          end
+        end
+
+        def merged_quantifier(exp1, exp2)
+          quantifier1 = mergeable_quantifier(exp1)
+          quantifier2 = mergeable_quantifier(exp2)
+          if quantifier1 == quantifier2
+            # (?:a+)+ equals (?:a+) ; (?:a*)* equals (?:a*) ; # (?:a?)? equals (?:a?)
+            quantifier1
+          else
+            # (?:a+)*, (?:a+)?, (?:a*)+, (?:a*)?, (?:a?)+, (?:a?)* - all equal (?:a*)
+            '*'
+          end
+        end
+
+        def quantifier_range(group, child)
+          range_between(child.loc.quantifier.begin_pos, group.loc.quantifier.end_pos)
+        end
+
+        def message(group, child, replacement)
+          format(
+            MSG_REDUNDANT_QUANTIFIER,
+            inner_quantifier: child.quantifier.to_s,
+            outer_quantifier: group.quantifier.to_s,
+            replacement: replacement
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -6,13 +6,27 @@ module RuboCop
       # Checks for unnecessary `require` statement.
       #
       # The following features are unnecessary `require` statement because
-      # they are already loaded.
+      # they are already loaded. e.g. Ruby 2.2:
       #
       #   ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }'
       #   ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]
       #   ["enumerator.so", "rational.so", "complex.so", "thread.rb"]
       #
-      # This cop targets Ruby 2.2 or higher containing these 4 features.
+      # Below are the features that each `TargetRubyVersion` targets.
+      #
+      #   * 2.0+ ... `enumerator`
+      #   * 2.1+ ... `thread`
+      #   * 2.2+ ... Add `rational` and `complex` above
+      #   * 2.5+ ... Add `pp` above
+      #   * 2.7+ ... Add `ruby2_keywords` above
+      #   * 3.1+ ... Add `fiber` above
+      #   * 3.2+ ... `set`
+      #
+      # This cop target those features.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because if `require 'pp'` is removed from one file,
+      #   `NameError` can be encountered when another file uses `PP.pp`.
       #
       # @example
       #   # bad
@@ -27,22 +41,58 @@ module RuboCop
 
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
+        RUBY_22_LOADED_FEATURES = %w[rational complex].freeze
+        PRETTY_PRINT_METHODS = %i[
+          pretty_inspect pretty_print pretty_print_cycle
+          pretty_print_inspect pretty_print_instance_variables
+        ].freeze
 
-        # @!method unnecessary_require_statement?(node)
-        def_node_matcher :unnecessary_require_statement?, <<~PATTERN
+        # @!method redundant_require_statement?(node)
+        def_node_matcher :redundant_require_statement?, <<~PATTERN
           (send nil? :require
-            (str {"enumerator" "rational" "complex" "thread"}))
+            (str #redundant_feature?))
+        PATTERN
+
+        # @!method pp_const?(node)
+        def_node_matcher :pp_const?, <<~PATTERN
+          (const {nil? cbase} :PP)
         PATTERN
 
         def on_send(node)
-          return unless unnecessary_require_statement?(node)
+          return unless redundant_require_statement?(node)
 
           add_offense(node) do |corrector|
-            range = range_with_surrounding_space(range: node.loc.expression, side: :right)
+            if node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+              corrector.insert_after(node.parent, "\nend")
+
+              range = range_with_surrounding_space(node.source_range, side: :right)
+            else
+              range = range_by_whole_lines(node.source_range, include_final_newline: true)
+            end
 
             corrector.remove(range)
           end
         end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def redundant_feature?(feature_name)
+          feature_name == 'enumerator' ||
+            (target_ruby_version >= 2.1 && feature_name == 'thread') ||
+            (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
+            (target_ruby_version >= 2.5 && feature_name == 'pp' && !need_to_require_pp?) ||
+            (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
+            (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
+            (target_ruby_version >= 3.2 && feature_name == 'set')
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def need_to_require_pp?
+          processed_source.ast.each_descendant(:send).any? do |node|
+            pp_const?(node.receiver) || PRETTY_PRINT_METHODS.include?(node.method_name)
+          end
+        end
       end
     end
   end