rubocop 1.87.0 → 1.88.1

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # Looks for uses of Perl-style regexp match
       # backreferences and their English versions like
-      # $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
+      # $1, $2, $&, $MATCH, $PREMATCH, etc.
       #
       # @example
       #   # bad
@@ -69,6 +69,10 @@ module RuboCop
         # @return [String, nil]
         def preferred_expression_to(node)
           first = node.to_a.first
+          # NOTE: `$+` / `$LAST_PAREN_MATCH` is deliberately not converted. It
+          # refers to the last group that actually matched, which has no concise
+          # `Regexp.last_match` equivalent (`Regexp.last_match(-1)` is the last
+          # group in the pattern, which may be `nil`).
           case first
           when ::Integer
             "Regexp.last_match(#{first})"
@@ -78,8 +82,6 @@ module RuboCop
             'Regexp.last_match.pre_match'
           when :$', :$POSTMATCH
             'Regexp.last_match.post_match'
-          when :$+, :$LAST_PAREN_MATCH
-            'Regexp.last_match(-1)'
           end
         end
 

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

@@ -38,6 +38,10 @@ module RuboCop
 
         def fix_exploded(node)
           exploded?(node) do |command, message|
+            # `raise RuntimeError, nil` uses the class name as the message, so
+            # rewriting it to `raise nil.to_s` (an empty message) would change it.
+            next if message.nil_type?
+
             add_offense(node, message: MSG_1) do |corrector|
               corrector.replace(node, replaced_exploded(node, command, message))
             end
@@ -56,6 +60,8 @@ module RuboCop
 
         def fix_compact(node)
           compact?(node) do |new_call, message|
+            next if message.nil_type?
+
             add_offense(node, message: MSG_2) do |corrector|
               corrector.replace(new_call, replaced_compact(message))
             end

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

@@ -62,7 +62,7 @@ module RuboCop
         def_node_matcher :select_predicate?, <<~PATTERN
           (call
             {
-              (block $(call _ {:select :filter :find_all}) ...)
+              (any_block $(call _ {:select :filter :find_all}) ...)
               $(call _ {:select :filter :find_all} block_pass_type?)
             }
             ${:#{RESTRICT_ON_SEND.join(' :')}})

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

@@ -89,6 +89,8 @@ module RuboCop
 
         def on_send(node)
           format_without_additional_args?(node) do |value|
+            next if string_with_format_sequence?(value)
+
             replacement = escape_control_chars(value.source)
 
             add_offense(node, message: message(node, replacement)) do |corrector|
@@ -102,12 +104,31 @@ module RuboCop
 
         private
 
+        # A single-argument `format` whose string still contains a format sequence is
+        # not redundant: `format('%s')` raises at runtime, and `format('%%')` returns
+        # `'%'`, so replacing it with the literal would change behavior.
+        def string_with_format_sequence?(node)
+          string = static_string_value(node)
+          return false unless string
+
+          RuboCop::Cop::Utils::FormatString.new(string).format_sequences.any?
+        end
+
+        def static_string_value(node)
+          if node.str_type?
+            node.value
+          elsif node.dstr_type?
+            node.children.select(&:str_type?).map(&:value).join
+          end
+        end
+
         def message(node, prefer)
           format(MSG, prefer: prefer, method_name: node.method_name)
         end
 
         def detect_unnecessary_fields(node)
           return unless node.first_argument&.str_type?
+          return if node.first_argument.heredoc?
 
           string = node.first_argument.value
           arguments = node.arguments[1..]
@@ -245,6 +266,14 @@ module RuboCop
         def argument_value(argument)
           argument = argument.children.first if argument.begin_type?
 
+          # `nil` formats to an empty string (`format('%s', nil) == ''`), not the
+          # literal `'nil'` that `argument.source` would return.
+          return if argument.nil_type?
+
+          typed_argument_value(argument)
+        end
+
+        def typed_argument_value(argument)
           if argument.dsym_type?
             dsym_value(argument)
           elsif argument.hash_type?

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

@@ -165,11 +165,11 @@ module RuboCop
         end
 
         def inspect_end_of_ruby_code_line_continuation
-          last_line = processed_source.lines[processed_source.ast.last_line - 1]
+          last_line_number = processed_source.ast.last_line
+          last_line = processed_source.lines[last_line_number - 1]
           return unless code_ends_with_continuation?(last_line)
 
-          last_column = last_line.length
-          line_continuation_range = range_between(last_column - 1, last_column)
+          line_continuation_range = trailing_line_continuation_range(last_line_number)
 
           add_offense(line_continuation_range) do |corrector|
             corrector.remove_trailing(line_continuation_range, 1)
@@ -182,6 +182,14 @@ module RuboCop
           last_line.end_with?(LINE_CONTINUATION)
         end
 
+        # The backslash is the last character of the line; locate it by the line's
+        # position in the buffer rather than treating the column as an absolute offset
+        # (which corrupts an earlier line in multi-line files).
+        def trailing_line_continuation_range(line_number)
+          line_range = processed_source.buffer.line_range(line_number)
+          range_between(line_range.end_pos - 1, line_range.end_pos)
+        end
+
         def inside_string_literal?(range, token)
           ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
         end

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

@@ -65,7 +65,7 @@ module RuboCop
           # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
-          return true if requires_escape_to_avoid_interpolation?(node.source[index], char)
+          return true if requires_escape_to_avoid_interpolation?(node, index, char)
 
           if within_character_class
             ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
@@ -97,10 +97,14 @@ module RuboCop
           delimiters.include?(char)
         end
 
-        def requires_escape_to_avoid_interpolation?(char_before_escape, escaped_char)
+        def requires_escape_to_avoid_interpolation?(node, index, escaped_char)
           # Preserve escapes after '#' that would otherwise trigger interpolation:
-          # '#@ivar', '#@@cvar', and '#$gvar'.
-          char_before_escape == '#' && INTERPOLATION_SIGILS.include?(escaped_char)
+          # '#@ivar', '#@@cvar', and '#$gvar'. `index` is relative to the regexp
+          # contents, so index into those rather than `node.source` (which also
+          # includes the opening delimiter, e.g. `%r{`).
+          return false unless index.positive? && INTERPOLATION_SIGILS.include?(escaped_char)
+
+          contents_range(node).source[index - 1] == '#'
         end
 
         def each_escape(node)

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

@@ -100,6 +100,15 @@ module RuboCop
           add_lhs_to_local_variables_scopes(node.rhs, node.lhs)
         end
 
+        # Register the exception variable of `rescue => e` so that `self.e` in the
+        # body is not treated as redundant (it disambiguates the local variable).
+        def on_resbody(node)
+          exception_variable = node.exception_variable
+          return unless exception_variable&.lvasgn_type?
+
+          @local_variables_scopes[node] << exception_variable.name
+        end
+
         def on_in_pattern(node)
           add_match_var_scopes(node)
         end

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

@@ -100,12 +100,31 @@ module RuboCop
         end
 
         def range(redundant_keyword_init)
-          if redundant_keyword_init.parent.left_siblings.last.is_a?(AST::Node)
-            beginning_of_range = redundant_keyword_init.parent.left_siblings.last.source_range.end
+          if redundant_keyword_init.parent.pairs.all? { |pair| keyword_init?(pair) }
+            # The hash holds only `keyword_init` pairs, so it is emptied; anchor the
+            # removal before the hash to also drop the comma that precedes it.
+            range_emptying_hash(redundant_keyword_init)
+          else
+            # Other pairs remain, so just drop this pair and one adjacent comma.
+            range_within_hash(redundant_keyword_init)
+          end
+        end
+
+        def range_within_hash(pair)
+          if (left = pair.left_sibling)
+            left.source_range.end.join(pair.source_range.end)
+          elsif (right = pair.right_sibling)
+            pair.source_range.begin.join(right.source_range.begin)
+          else
+            pair.source_range
+          end
+        end
 
-            beginning_of_range.join(redundant_keyword_init.source_range.end)
+        def range_emptying_hash(pair)
+          if (preceding = pair.parent.left_sibling).is_a?(AST::Node)
+            preceding.source_range.end.join(pair.source_range.end)
           else
-            redundant_keyword_init
+            pair.source_range
           end
         end
       end

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

@@ -128,7 +128,7 @@ module RuboCop
 
           add_offense(range) do |corrector|
             if after_expression
-              corrector.replace(range, "\n")
+              replace_semicolon_with_line_break(corrector, range)
             else
               # Prevents becoming one range instance with subsequent line when endless range
               # without parentheses.
@@ -148,6 +148,21 @@ module RuboCop
         end
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
+        def replace_semicolon_with_line_break(corrector, range)
+          # Replacing the semicolon with a newline would move the rest of the
+          # line into the body of a heredoc opened earlier on that line.
+          return if heredoc_opened_before_semicolon?(range)
+
+          corrector.replace(range, "\n")
+        end
+
+        def heredoc_opened_before_semicolon?(semicolon_range)
+          processed_source.ast.each_descendant(:any_str).select(&:heredoc?).any? do |heredoc|
+            heredoc.first_line == semicolon_range.line &&
+              heredoc.source_range.end_pos <= semicolon_range.begin_pos
+          end
+        end
+
         def expressions_per_line(exprs)
           # create a map matching lines to the number of expressions on them
           exprs_lines = exprs.map(&:last_line)
@@ -155,10 +170,10 @@ module RuboCop
         end
 
         def find_semicolon_positions(line)
-          # Scan for all the semicolons on the line
-          semicolons = processed_source[line - 1].enum_for(:scan, ';')
-          semicolons.each do
-            yield Regexp.last_match.begin(0)
+          # Scan for all the semicolon tokens on the line. Iterating tokens rather
+          # than the raw source skips `;` characters inside string/regexp literals.
+          processed_source.tokens.each do |token|
+            yield token.column if token.line == line && token.semicolon?
           end
         end
 

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

@@ -44,11 +44,12 @@ module RuboCop
           add_offense(node) do |corrector|
             corrector.insert_after(do_line(node), "\n")
 
-            node_body = node.body
-
-            if node_body.respond_to?(:heredoc?) && node_body.heredoc?
+            if (heredoc = trailing_heredoc(node.body))
+              # The heredoc body extends past the `end` on the source, so the
+              # `end` has to be moved after it rather than before, which would
+              # otherwise move it into the heredoc body and break the syntax.
               corrector.remove(node.loc.end)
-              corrector.insert_after(node_body.loc.heredoc_end, "\nend")
+              corrector.insert_after(heredoc.loc.heredoc_end, "\nend")
             else
               corrector.insert_before(node.loc.end, "\n")
             end
@@ -60,6 +61,18 @@ module RuboCop
 
         private
 
+        # Returns the heredoc opened on the block's line whose body extends the
+        # furthest down, whether it is the block body itself or nested within it.
+        def trailing_heredoc(node_body)
+          return unless node_body
+
+          heredocs = [node_body, *node_body.each_descendant].select do |node|
+            node.respond_to?(:heredoc?) && node.heredoc?
+          end
+
+          heredocs.max_by { |heredoc| heredoc.loc.heredoc_end.line }
+        end
+
         def do_line(node)
           if node.type?(:numblock, :itblock) ||
              node.arguments.children.empty? || node.send_node.lambda_literal?

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

@@ -41,6 +41,7 @@ module RuboCop
 
         def on_pair(node)
           return unless string_hash_key?(node)
+          return if node.key.heredoc?
 
           key_content = node.key.str_content
           return unless key_content.valid_encoding?

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

@@ -113,6 +113,10 @@ module RuboCop
         def offense?(node)
           condition = node.condition
 
+          # A modifier `if`/`unless` requires the parentheses, e.g. `(a if b) ? x : y`,
+          # so removing them would change the meaning. Don't flag it.
+          return false if parenthesized_modifier_condition?(condition)
+
           if safe_assignment?(condition)
             !safe_assignment_allowed?
           else
@@ -174,6 +178,13 @@ module RuboCop
           condition.children.any? { |child| below_ternary_precedence?(child) }
         end
 
+        def parenthesized_modifier_condition?(condition)
+          return false unless condition.begin_type?
+
+          inner = condition.children.first
+          inner&.if_type? && inner.modifier_form?
+        end
+
         def unparenthesized_method_call?(child)
           /^[a-z]/i.match?(method_name(child)) && !child.parenthesized?
         end

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

@@ -113,9 +113,7 @@ module RuboCop
 
           return unless first_offense
 
-          if unused_variables_only?(first_offense, variables)
-            return unused_range(node.type, mlhs_node, node.rhs)
-          end
+          return unused_range(node, mlhs_node) if unused_variables_only?(first_offense, variables)
 
           return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)
 
@@ -130,13 +128,14 @@ module RuboCop
           offense.source_range == variables.first.source_range
         end
 
-        def unused_range(node_type, mlhs_node, right)
+        def unused_range(node, mlhs_node)
           start_range = mlhs_node.source_range.begin_pos
 
-          end_range = case node_type
-                      when :masgn
-                        right.source_range.begin_pos
-                      when :mlhs
+          # `node` can be an `mlhs` when recursing into a nested destructuring
+          # group; only a `masgn` has a right-hand side to anchor against.
+          end_range = if node.masgn_type?
+                        node.rhs.source_range.begin_pos
+                      else
                         mlhs_node.source_range.end_pos
                       end
 

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

@@ -33,6 +33,7 @@ module RuboCop
 
         def on_while(node)
           return unless node.multiline? && node.do?
+          return if same_line_body?(node)
 
           add_offense(node.loc.begin, message: format(MSG, keyword: node.keyword)) do |corrector|
             do_range = node.condition.source_range.end.join(node.loc.begin)
@@ -41,6 +42,12 @@ module RuboCop
           end
         end
         alias on_until on_while
+
+        private
+
+        def same_line_body?(node)
+          node.body && same_line?(node.loc.begin, node.body)
+        end
       end
     end
   end

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

@@ -93,6 +93,7 @@ module RuboCop
 
         def on_array(node)
           if bracketed_array_of?(:str, node)
+            return if node.values.any?(&:heredoc?)
             return if complex_content?(node.values)
             return if within_matrix_of_complex_content?(node)
 

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

@@ -9,8 +9,10 @@ module RuboCop
       # `receiver.length < 1` and `receiver.size == 0` that can be
       # replaced by `receiver.empty?` and `!receiver.empty?`.
       #
-      # NOTE: `File`, `Tempfile`, and `StringIO` do not have `empty?`
-      # so allow `size == 0` and `size.zero?`.
+      # NOTE: `File`, `Tempfile`, `StringIO`, and `File::Stat` do not have `empty?`
+      # so allow `size == 0` and `size.zero?`. Note that when a `File::Stat` object
+      # is stored in a variable (e.g. `stat = File.stat(path); stat.size.zero?`),
+      # the cop cannot detect the type and may still register a false positive.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -146,7 +148,8 @@ module RuboCop
         # @!method non_polymorphic_collection?(node)
         def_node_matcher :non_polymorphic_collection?, <<~PATTERN
           {(send (send (send (const {nil? cbase} :File) :stat _) ...) ...)
-           (send (send (send (const {nil? cbase} {:File :Tempfile :StringIO}) {:new :open} ...) ...) ...)}
+           (send (send (send (const {nil? cbase} {:File :Tempfile :StringIO}) {:new :open} ...) ...) ...)
+           (send (send (send (const (const {nil? cbase} :File) :Stat) :new ...) ...) ...)}
         PATTERN
       end
     end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -91,12 +91,9 @@ module RuboCop
         command = 'rubocop --auto-gen-config'
 
         command += ' --auto-gen-only-exclude' if @options[:auto_gen_only_exclude]
-
-        if no_exclude_limit?
-          command += ' --no-exclude-limit'
-        elsif @exclude_limit_option
-          command += format(' --exclude-limit %<limit>d', limit: Integer(@exclude_limit_option))
-        end
+        command += ' --disable-pending-cops' if @options[:disable_pending_cops]
+        command += ' --enable-pending-cops' if @options[:enable_pending_cops]
+        command += exclude_limit_option
         command += ' --no-offense-counts' unless show_offense_counts?
 
         command += ' --no-auto-gen-timestamp' unless show_timestamp?
@@ -106,6 +103,16 @@ module RuboCop
         command
       end
 
+      def exclude_limit_option
+        if no_exclude_limit?
+          ' --no-exclude-limit'
+        elsif @exclude_limit_option
+          format(' --exclude-limit %<limit>d', limit: Integer(@exclude_limit_option))
+        else
+          ''
+        end
+      end
+
       def timestamp
         show_timestamp? ? "on #{Time.now.utc} " : ''
       end
@@ -158,7 +165,7 @@ module RuboCop
         output_buffer.puts "# Offense count: #{offense_count}" if show_offense_counts?
 
         cop_class = Cop::Registry.global.find_by_cop_name(cop_name)
-        default_cfg = default_config(cop_name)
+        default_cfg = default_config(cop_name) || @config_for_pwd[cop_name]
 
         if supports_safe_autocorrect?(cop_class, default_cfg)
           output_buffer.puts '# This cop supports safe autocorrection (--autocorrect).'

data/lib/rubocop/runner.rb

@@ -120,7 +120,6 @@ module RuboCop
       file_iterator(files) do |file|
         offenses = process_file(file)
         succeeded = offenses.none? { |o| considered_failure?(o) && offense_displayed?(o) }
-        raise Parallel::Break if @options[:fail_fast] && !succeeded
 
         [offenses, succeeded]
       end
@@ -211,8 +210,11 @@ module RuboCop
         on_start.call(file, index)
         result = yield file
         on_finish.call(file, index, result)
-      rescue Parallel::Break
-        break
+
+        # Report and count the offending file before stopping so `--fail-fast`
+        # still shows its offenses and exits with a failing status.
+        _offenses, succeeded = result
+        break if @options[:fail_fast] && !succeeded
       end
     end
 

data/lib/rubocop/server/core.rb

@@ -57,6 +57,12 @@ module RuboCop
         end
 
         Process.waitpid(pid)
+
+        # The daemon writes its pid file asynchronously after forking, so wait until
+        # the server is actually running before returning. This prevents a race where
+        # a subsequent command (e.g. `--restart-server`) observes an inconsistent
+        # state right after `--start-server` returns.
+        Server.wait_for_running_status!(true)
       end
 
       def write_port_and_token_files

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.87.0'
+    STRING = '1.88.1'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.87.0
+  version: 1.88.1
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -1119,9 +1119,9 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://rubocop.org/
-  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.87.0
+  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.88.1
   source_code_uri: https://github.com/rubocop/rubocop/
-  documentation_uri: https://docs.rubocop.org/rubocop/1.87/
+  documentation_uri: https://docs.rubocop.org/rubocop/1.88/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues
   rubygems_mfa_required: 'true'
 rdoc_options: []