rubocop 1.80.1 → 1.81.0

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

@@ -134,6 +134,7 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def all_fields_literal?(string, arguments)
           count = 0
           sequences = RuboCop::Cop::Utils::FormatString.new(string).format_sequences
@@ -141,6 +142,7 @@ module RuboCop
 
           sequences.each do |sequence|
             next if sequence.percent?
+            next if unknown_variable_width?(sequence, arguments)
 
             hash = arguments.detect(&:hash_type?)
             next unless (argument = find_argument(sequence, arguments, hash))
@@ -151,19 +153,32 @@ module RuboCop
 
           sequences.size == count
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
+        # If the sequence has a variable (`*`) width, it cannot be autocorrected
+        # if the width is not given as a numeric literal argument
+        def unknown_variable_width?(sequence, arguments)
+          return false unless sequence.variable_width?
+
+          argument = arguments[sequence.variable_width_argument_number - 1]
+          !numeric?(argument)
+        end
+
+        # rubocop:disable Metrics/AbcSize
         def find_argument(sequence, arguments, hash)
           if hash && (sequence.annotated? || sequence.template?)
             find_hash_value_node(hash, sequence.name.to_sym).first
+          elsif sequence.variable_width?
+            # If the specifier contains `*`, the argument for the width can be ignored.
+            arguments.delete_at(sequence.variable_width_argument_number - 1)
+            arguments.shift
           elsif sequence.arg_number
             arguments[sequence.arg_number.to_i - 1]
           else
-            # If the specifier contains `*`, the following arguments will be used
-            # to specify the width and can be ignored.
-            (sequence.arity - 1).times { arguments.shift }
             arguments.shift
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def matching_argument?(sequence, argument)
           # Template specifiers don't give a type, any acceptable literal type is ok.

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

@@ -24,9 +24,6 @@ module RuboCop
           (send `{(send _recv _msg) str array hash const #variable?} :[] ...)
         PATTERN
 
-        # @!method method_node_and_args(node)
-        def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
-
         # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
 
@@ -205,6 +202,7 @@ module RuboCop
           return false unless node.rescue_type?
           return false unless (parent = begin_node.parent)
           return false if parent.if_type? && parent.ternary?
+          return false if parent.conditional? && parent.condition == begin_node
 
           !parent.type?(:call, :array, :pair)
         end
@@ -228,7 +226,7 @@ module RuboCop
 
           return check_unary(begin_node, node) if node.unary_operation?
 
-          return unless method_call_with_redundant_parentheses?(node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
           return if call_chain_starts_with_int?(begin_node, node) ||
                     do_end_block_in_method_chain?(begin_node, node)
 
@@ -239,8 +237,7 @@ module RuboCop
           return if begin_node.chained?
 
           node = node.children.first while suspect_unary?(node)
-
-          return if node.send_type? && !method_call_with_redundant_parentheses?(node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
 
           offense(begin_node, 'a unary operation')
         end
@@ -302,13 +299,19 @@ module RuboCop
           end
         end
 
-        def method_call_with_redundant_parentheses?(node)
-          return false unless node.call_type?
+        def method_call_with_redundant_parentheses?(begin_node, node)
+          return false unless node.type?(:call, :super, :yield, :defined?)
           return false if node.prefix_not?
+          return true if singular_parenthesized_parent?(begin_node)
+
+          node.arguments.empty? || parentheses?(node) || square_brackets?(node)
+        end
 
-          send_node, args = method_node_and_args(node)
+        def singular_parenthesized_parent?(begin_node)
+          return true unless begin_node.parent
+          return false if begin_node.parent.type?(:splat, :kwsplat)
 
-          args.empty? || parentheses?(send_node) || square_brackets?(send_node)
+          parentheses?(begin_node) && begin_node.parent.children.one?
         end
 
         def only_begin_arg?(args)

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

@@ -66,6 +66,7 @@ module RuboCop
           DETERMINISTIC_REGEX.match?(regexp_node.source)
         end
 
+        # rubocop:disable Metrics/MethodLength
         def preferred_argument(regexp_node)
           new_argument = replacement(regexp_node)
 
@@ -73,6 +74,8 @@ module RuboCop
             new_argument.gsub!("'", "\\\\'")
             new_argument.gsub!('\"', '"')
             quote = "'"
+          elsif new_argument.include?("\\'")
+            quote = "'"
           elsif new_argument.include?('\'')
             new_argument.gsub!("'", "\\\\'")
             quote = "'"
@@ -84,6 +87,7 @@ module RuboCop
 
           "#{quote}#{new_argument}#{quote}"
         end
+        # rubocop:enable Metrics/MethodLength
 
         def replacement(regexp_node)
           regexp_content = regexp_node.content

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

@@ -41,6 +41,7 @@ module RuboCop
         ALLOWED_ALWAYS_ESCAPES = " \n[]^\\#".chars.freeze
         ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = '-'.chars.freeze
         ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = '.*+?{}()|$'.chars.freeze
+        INTERPOLATION_SIGILS = %w[@ $].freeze
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
@@ -64,6 +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)
 
           if within_character_class
             ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
@@ -95,6 +97,12 @@ module RuboCop
           delimiters.include?(char)
         end
 
+        def requires_escape_to_avoid_interpolation?(char_before_escape, escaped_char)
+          # Preserve escapes after '#' that would otherwise trigger interpolation:
+          # '#@ivar', '#@@cvar', and '#$gvar'.
+          char_before_escape == '#' && INTERPOLATION_SIGILS.include?(escaped_char)
+        end
+
         def each_escape(node)
           node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
             yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape

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

@@ -262,8 +262,14 @@ module RuboCop
         end
 
         def dotless_operator_call?(method_call)
+          return true if dotless_operator_method?(method_call)
+
           method_call = method_call.parent while method_call.parent.send_type?
 
+          dotless_operator_method?(method_call)
+        end
+
+        def dotless_operator_method?(method_call)
           return false if method_call.loc.dot
 
           method_call.method?(:[]) || method_call.method?(:[]=) || method_call.operator_method?

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

@@ -141,22 +141,26 @@ module RuboCop
         end
 
         def replacement(parts)
-          interpolated_parts = parts.map do |part|
-            case part.type
-            when :str
-              adjust_str(part)
-            when :dstr
-              part.children.all?(&:str_type?) ? adjust_str(part) : part.value
-            else
-              "\#{#{part.source}}"
-            end
-          end
+          interpolated_parts = parts.map { |part| adjust_str(part) }
 
           "\"#{handle_quotes(interpolated_parts).join}\""
         end
 
-        def adjust_str(node)
-          single_quoted?(node) ? node.value.gsub(/(\\|")/, '\\\\\&') : node.value.inspect[1..-2]
+        def adjust_str(part)
+          case part.type
+          when :str
+            if single_quoted?(part)
+              part.value.gsub(/(\\|"|#\{|#@|#\$)/, '\\\\\&')
+            else
+              part.value.inspect[1..-2]
+            end
+          when :dstr, :begin
+            part.children.map do |child|
+              adjust_str(child)
+            end.join
+          else
+            "\#{#{part.source}}"
+          end
         end
 
         def handle_quotes(parts)

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

@@ -10,6 +10,9 @@ module RuboCop
       # for all parenthesized multi-line method calls with arguments.
       # * `comma`: Requires a comma after the last argument, but only for
       # parenthesized method calls where each argument is on its own line.
+      # * `diff_comma`: Requires a comma after the last argument, but only
+      # when that argument is followed by an immediate newline, even if
+      # there is an inline comment on the same line.
       # * `no_comma`: Requires that there is no comma after the last
       # argument.
       #
@@ -75,6 +78,48 @@ module RuboCop
       #     2,
       #   )
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
+      #   method(1, 2)
+      #
+      #   # good
+      #   method(
+      #     1, 2,
+      #     3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1, 2, 3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1,
+      #     2,
+      #   )
+      #
+      #   # bad
+      #   method(1, [
+      #     2,
+      #   ],)
+      #
+      #   # good
+      #   method(1, [
+      #     2,
+      #   ])
+      #
+      #   # bad
+      #   object[1, 2,
+      #          3, 4,]
+      #
+      #   # good
+      #   object[1, 2,
+      #          3, 4]
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #   # bad
       #   method(1, 2,)

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

@@ -20,7 +20,6 @@ module RuboCop
       #     # do a different thing...
       #   end
       class UnlessElse < Base
-        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Do not use `unless` with `else`. Rewrite these with the positive case first.'
@@ -29,25 +28,27 @@ module RuboCop
           return unless node.unless? && node.else?
 
           add_offense(node) do |corrector|
-            body_range = range_between_condition_and_else(node, node.condition)
-            else_range = range_between_else_and_end(node)
-
             next if part_of_ignored_node?(node)
 
             corrector.replace(node.loc.keyword, 'if')
-            corrector.replace(body_range, else_range.source)
-            corrector.replace(else_range, body_range.source)
+
+            body_range = range_between_condition_and_else(node)
+            else_range = range_between_else_and_end(node)
+
+            corrector.swap(body_range, else_range)
           end
 
           ignore_node(node)
         end
 
-        def range_between_condition_and_else(node, condition)
-          range_between(condition.source_range.end_pos, node.loc.else.begin_pos)
+        def range_between_condition_and_else(node)
+          range = node.loc.begin ? node.loc.begin.end : node.condition.source_range
+
+          range.end.join(node.loc.else.begin)
         end
 
         def range_between_else_and_end(node)
-          range_between(node.loc.else.end_pos, node.loc.end.begin_pos)
+          node.loc.else.end.join(node.loc.end.begin)
         end
       end
     end

data/lib/rubocop/cop/utils/format_string.rb

@@ -71,6 +71,16 @@ module RuboCop
             name && @source.include?('{')
           end
 
+          def variable_width?
+            !!width&.start_with?('*')
+          end
+
+          def variable_width_argument_number
+            return unless variable_width?
+
+            width == '*' ? 1 : width.match(DIGIT_DOLLAR)['arg_number'].to_i
+          end
+
           # Number of arguments required for the format sequence
           def arity
             @source.scan('*').count + 1

data/lib/rubocop/lsp/diagnostic.rb

@@ -16,8 +16,8 @@ module RuboCop
     # Diagnostic for Language Server Protocol of RuboCop.
     # @api private
     class Diagnostic
-      def initialize(document_encoding, offense, uri, cop_class)
-        @document_encoding = document_encoding
+      def initialize(position_encoding, offense, uri, cop_class)
+        @position_encoding = position_encoding
         @offense = offense
         @uri = uri
         @cop_class = cop_class
@@ -45,11 +45,11 @@ module RuboCop
           range: LanguageServer::Protocol::Interface::Range.new(
             start: LanguageServer::Protocol::Interface::Position.new(
               line: @offense.line - 1,
-              character: highlighted.begin_pos
+              character: to_position_character(highlighted.begin_pos)
             ),
             end: LanguageServer::Protocol::Interface::Position.new(
               line: @offense.line - 1,
-              character: highlighted.end_pos
+              character: to_position_character(highlighted.end_pos)
             )
           ),
           data: {
@@ -107,11 +107,11 @@ module RuboCop
             range: LanguageServer::Protocol::Interface::Range.new(
               start: LanguageServer::Protocol::Interface::Position.new(
                 line: range.line - 1,
-                character: range.column
+                character: to_position_character(range.column)
               ),
               end: LanguageServer::Protocol::Interface::Position.new(
                 line: range.last_line - 1,
-                character: range.last_column
+                character: to_position_character(range.last_column)
               )
             ),
             new_text: replacement
@@ -149,7 +149,7 @@ module RuboCop
 
         eol = LanguageServer::Protocol::Interface::Position.new(
           line: @offense.line - 1,
-          character: length_of_line(@offense.source_line)
+          character: to_position_character
         )
 
         # TODO: fails for multiline strings - may be preferable to use block
@@ -162,19 +162,6 @@ module RuboCop
         [inline_comment]
       end
 
-      def length_of_line(line)
-        if @document_encoding == Encoding::UTF_16LE
-          line_length = 0
-          line.codepoints.each do |codepoint|
-            line_length += 1
-            line_length += 1 if codepoint > RubyLsp::Document::Scanner::SURROGATE_PAIR_START
-          end
-          line_length
-        else
-          line.length
-        end
-      end
-
       def correctable?
         !@offense.corrector.nil?
       end
@@ -184,6 +171,20 @@ module RuboCop
         uri.scheme = 'file' if uri.scheme.nil?
         uri
       end
+
+      def to_position_character(utf8_index = nil)
+        str = utf8_index ? @offense.source_line[0, utf8_index] : @offense.source_line
+        case @position_encoding
+        when 'utf-8', Encoding::UTF_8
+          str.bytesize
+        when 'utf-32', Encoding::UTF_32
+          str.size
+        else # 'utf-16'
+          # utf-16 is default position encoding on LSP
+          # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/
+          str.size + str.count("\u{10000}-\u{10FFFF}")
+        end
+      end
     end
   end
 end

data/lib/rubocop/lsp/routes.rb

@@ -15,7 +15,7 @@ module RuboCop
   module LSP
     # Routes for Language Server Protocol of RuboCop.
     # @api private
-    class Routes
+    class Routes # rubocop:disable Metrics/ClassLength
       CONFIGURATION_FILE_PATTERNS = [
         RuboCop::ConfigFinder::DOTFILE,
         RuboCop::CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE
@@ -42,6 +42,7 @@ module RuboCop
 
       handle 'initialize' do |request|
         initialization_options = extract_initialization_options_from(request)
+        @position_encoding = initialization_options[:position_encoding]
 
         @server.configure(initialization_options)
 
@@ -53,7 +54,8 @@ module RuboCop
               text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
                 change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::INCREMENTAL,
                 open_close: true
-              )
+              ),
+              position_encoding: @position_encoding
             )
           )
         )
@@ -184,14 +186,26 @@ module RuboCop
 
       def extract_initialization_options_from(request)
         safe_autocorrect = request.dig(:params, :initializationOptions, :safeAutocorrect)
+        position_encodings = request.dig(:params, :capabilities, :general, :positionEncodings)
 
         {
           safe_autocorrect: safe_autocorrect.nil? || safe_autocorrect == true,
           lint_mode: request.dig(:params, :initializationOptions, :lintMode) == true,
-          layout_mode: request.dig(:params, :initializationOptions, :layoutMode) == true
+          layout_mode: request.dig(:params, :initializationOptions, :layoutMode) == true,
+          position_encoding: position_encoding(position_encodings)
         }
       end
 
+      def position_encoding(position_encodings)
+        if position_encodings&.include?('utf-8')
+          'utf-8'
+        elsif position_encodings&.include?('utf-32')
+          'utf-32'
+        else
+          'utf-16'
+        end
+      end
+
       def format_file(file_uri, command: nil)
         unless (text = @text_cache[file_uri])
           Logger.log("Format request arrived before text synchronized; skipping: `#{file_uri}'")
@@ -219,7 +233,8 @@ module RuboCop
           method: 'textDocument/publishDiagnostics',
           params: {
             uri: file_uri,
-            diagnostics: @server.offenses(convert_file_uri_to_path(file_uri), text)
+            diagnostics: @server.offenses(convert_file_uri_to_path(file_uri),
+                                          text, @position_encoding)
           }
         }
       end
@@ -229,9 +244,8 @@ module RuboCop
 
         start_pos = text_pos(orig_text, range[:start])
         end_pos = text_pos(orig_text, range[:end])
-        text_bin = orig_text.b
-        text_bin[start_pos...end_pos] = text.b
-        text_bin.force_encoding(orig_text.encoding)
+        orig_text[start_pos...end_pos] = text
+        orig_text
       end
 
       def text_pos(text, range)
@@ -240,14 +254,27 @@ module RuboCop
         pos = 0
         text.each_line.with_index do |l, i|
           if i == line
-            pos += l.encode('utf-16be').b[0, char * 2].encode('utf-8', 'utf-16be').bytesize
+            pos += line_pos(l, char)
             return pos
           end
-          pos += l.bytesize
+          pos += l.size
         end
         pos
       end
 
+      def line_pos(line, char)
+        case @position_encoding
+        when 'utf-8'
+          line.byteslice(0, char).size
+        when 'utf-32'
+          char
+        else # 'utf-16'
+          # utf-16 is default position encoding on LSP
+          # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/
+          line.encode('utf-16be').byteslice(0, char * 2).size
+        end
+      end
+
       def convert_file_uri_to_path(uri)
         URI.decode_www_form_component(uri.delete_prefix('file://'))
       end

data/lib/rubocop/lsp/runtime.rb

@@ -44,14 +44,14 @@ module RuboCop
         @runner.formatted_source
       end
 
-      def offenses(path, text, document_encoding = nil, prism_result: nil)
+      def offenses(path, text, position_encoding, prism_result: nil)
         diagnostic_options = {}
         diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
 
         @runner.run(path, text, diagnostic_options, prism_result: prism_result)
         @runner.offenses.map do |offense|
           Diagnostic.new(
-            document_encoding, offense, path, @cop_registry[offense.cop_name]&.first
+            position_encoding, offense, path, @cop_registry[offense.cop_name]&.first
           ).to_lsp_diagnostic(@runner.config_for_working_directory)
         end
       end

data/lib/rubocop/lsp/server.rb

@@ -51,8 +51,8 @@ module RuboCop
         @runtime.format(path, text, command: command)
       end
 
-      def offenses(path, text)
-        @runtime.offenses(path, text)
+      def offenses(path, text, position_encoding)
+        @runtime.offenses(path, text, position_encoding)
       end
 
       def configure(options)

data/lib/rubocop/lsp/stdin_runner.rb

@@ -40,7 +40,6 @@ module RuboCop
         super(@options, config_store)
       end
 
-      # rubocop:disable Metrics/MethodLength
       def run(path, contents, options, prism_result: nil)
         @options = options.merge(DEFAULT_RUBOCOP_OPTIONS)
         @options[:stdin] = contents
@@ -54,22 +53,7 @@ module RuboCop
         super([path])
 
         raise Interrupt if aborting?
-      rescue RuboCop::Runner::InfiniteCorrectionLoop => e
-        if defined?(::RubyLsp::Requests::Formatting::Error)
-          raise ::RubyLsp::Requests::Formatting::Error, e.message
-        end
-
-        raise e
-      rescue RuboCop::ValidationError => e
-        raise ConfigurationError, e.message
-      rescue StandardError => e
-        if defined?(::RubyLsp::Requests::Formatting::Error)
-          raise ::RubyLsp::Requests::Support::InternalRuboCopError, e
-        end
-
-        raise e
       end
-      # rubocop:enable Metrics/MethodLength
 
       def formatted_source
         @options[:stdin]

data/lib/rubocop/target_ruby.rb

@@ -110,8 +110,17 @@ module RuboCop
       end
 
       def version_from_gemspec_file(file)
+        # When using parser_prism, we need to use a Ruby version that Prism supports (3.3+)
+        # for parsing the gemspec file. This doesn't affect the detected Ruby version,
+        # it's just for the parsing step.
+        ruby_version_for_parsing = if @config.parser_engine == :parser_prism
+                                     3.3
+                                   else
+                                     DEFAULT_VERSION
+                                   end
+
         processed_source = ProcessedSource.from_file(
-          file, DEFAULT_VERSION, parser_engine: @config.parser_engine
+          file, ruby_version_for_parsing, parser_engine: @config.parser_engine
         )
         return unless processed_source.valid_syntax?
 

data/lib/rubocop/version.rb

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

data/lib/rubocop.rb

@@ -489,6 +489,7 @@ require_relative 'rubocop/cop/style/arguments_forwarding'
 require_relative 'rubocop/cop/style/array_coercion'
 require_relative 'rubocop/cop/style/array_first_last'
 require_relative 'rubocop/cop/style/array_intersect'
+require_relative 'rubocop/cop/style/array_intersect_with_single_element'
 require_relative 'rubocop/cop/style/array_join'
 require_relative 'rubocop/cop/style/ascii_comments'
 require_relative 'rubocop/cop/style/attr'