rubocop 1.68.0 → 1.71.2

data/lib/rubocop/cop/util.rb

@@ -74,9 +74,9 @@ module RuboCop
 
       def args_begin(node)
         loc = node.loc
-        selector = if node.super_type? || node.yield_type?
+        selector = if node.type?(:super, :yield)
                      loc.keyword
-                   elsif node.def_type? || node.defs_type?
+                   elsif node.type?(:def, :defs)
                      loc.name
                    else
                      loc.selector
@@ -193,11 +193,18 @@ module RuboCop
           enforced_style.sub(/^Enforced/, 'Supported').sub('Style', 'Styles')
       end
 
+      def parse_regexp(text)
+        Regexp::Parser.parse(text)
+      rescue Regexp::Parser::Error
+        # Upon encountering an invalid regular expression,
+        # we aim to proceed and identify any remaining potential offenses.
+        nil
+      end
+
       private
 
       def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_ENGINE == 'jruby'
-        src.force_encoding(Encoding.default_external).valid_encoding?
+        src.dup.force_encoding(Encoding.default_external).valid_encoding?
       end
 
       def include_or_equal?(source, target)

data/lib/rubocop/cop/variable_force/variable.rb

@@ -6,6 +6,8 @@ module RuboCop
       # A Variable represents existence of a local variable.
       # This holds a variable declaration node and some states of the variable.
       class Variable
+        extend NodePattern::Macros
+
         VARIABLE_DECLARATION_TYPES = (VARIABLE_ASSIGNMENT_TYPES + ARGUMENT_DECLARATION_TYPES).freeze
 
         attr_reader :name, :declaration_node, :scope, :assignments, :references, :captured_by_block
@@ -31,11 +33,21 @@ module RuboCop
         def assign(node)
           assignment = Assignment.new(node, self)
 
-          @assignments.last&.reassigned! unless captured_by_block?
+          mark_last_as_reassigned!(assignment)
 
           @assignments << assignment
         end
 
+        def mark_last_as_reassigned!(assignment)
+          return if captured_by_block?
+          return if candidate_condition?(assignment.node.parent)
+
+          @assignments.last&.reassigned!
+        end
+
+        # @!method candidate_condition?(node)
+        def_node_matcher :candidate_condition?, '[{if case case_match when}]'
+
         def referenced?
           !@references.empty?
         end
@@ -72,7 +84,7 @@ module RuboCop
           parent = parent.parent if parent&.begin_type?
           return false if parent.nil?
 
-          (parent.if_type? || parent.while_type? || parent.until_type?) && parent.modifier_form?
+          parent.type?(:if, :while, :until) && parent.modifier_form?
         end
 
         def capture_with_block!

data/lib/rubocop/cop/variable_force/variable_table.rb

@@ -100,7 +100,7 @@ module RuboCop
 
             # Only block scope allows referencing outer scope variables.
             node = scope.node
-            return nil unless node.block_type? || node.numblock_type?
+            return nil unless node.any_block_type?
           end
 
           nil
@@ -113,14 +113,14 @@ module RuboCop
         def accessible_variables
           scope_stack.reverse_each.with_object([]) do |scope, variables|
             variables.concat(scope.variables.values)
-            break variables unless scope.node.block_type? || scope.node.numblock_type?
+            break variables unless scope.node.any_block_type?
           end
         end
 
         private
 
         def mark_variable_as_captured_by_block_if_so(variable)
-          return unless current_scope.node.block_type? || current_scope.node.numblock_type?
+          return unless current_scope.node.any_block_type?
           return if variable.scope == current_scope
 
           variable.capture_with_block!

data/lib/rubocop/cop/variable_force.rb

@@ -194,15 +194,10 @@ module RuboCop
       end
 
       def process_variable_operator_assignment(node)
-        if LOGICAL_OPERATOR_ASSIGNMENT_TYPES.include?(node.type)
-          asgn_node, rhs_node = *node
-        else
-          asgn_node, _operator, rhs_node = *node
-        end
-
+        asgn_node = node.lhs
         return unless asgn_node.lvasgn_type?
 
-        name = asgn_node.children.first
+        name = asgn_node.name
 
         variable_table.declare_variable(name, asgn_node) unless variable_table.variable_exist?(name)
 
@@ -222,7 +217,7 @@ module RuboCop
         # before processing rhs nodes.
 
         variable_table.reference_variable(name, node)
-        process_node(rhs_node)
+        process_node(node.rhs)
         variable_table.assign_to_variable(name, asgn_node)
 
         skip_children!
@@ -355,8 +350,7 @@ module RuboCop
         when :lvasgn
           AssignmentReference.new(node)
         when *OPERATOR_ASSIGNMENT_TYPES
-          asgn_node = node.children.first
-          VariableReference.new(asgn_node.children.first) if asgn_node.lvasgn_type?
+          VariableReference.new(node.lhs.name) if node.lhs.lvasgn_type?
         end
       end
 

data/lib/rubocop/cops_documentation_generator.rb

@@ -18,7 +18,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     description:           ->(data) { "#{data.description}\n" },
     safety:                ->(data) { safety_object(data.safety_objects, data.cop) },
     examples:              ->(data) { examples(data.example_objects, data.cop) },
-    configuration:         ->(data) { configurations(data.cop.department, data.config, data.cop) },
+    configuration:         ->(data) { configurations(data.cop.department, data.cop, data.config) },
     references:            ->(data) { references(data.cop, data.see_objects) }
   }.freeze
 
@@ -114,7 +114,15 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   def required_ruby_version(cop)
     return '' unless cop.respond_to?(:required_minimum_ruby_version)
 
-    "NOTE: Required Ruby version: #{cop.required_minimum_ruby_version}\n\n"
+    if cop.required_minimum_ruby_version
+      requirement = cop.required_minimum_ruby_version
+    elsif cop.required_maximum_ruby_version
+      requirement = "<= #{cop.required_maximum_ruby_version}"
+    else
+      return ''
+    end
+
+    "NOTE: Requires Ruby version #{requirement}\n\n"
   end
 
   # rubocop:disable Metrics/MethodLength
@@ -172,17 +180,17 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     content
   end
 
-  def configurations(department, pars, cop)
-    return '' if pars.empty?
-
+  def configurations(department, cop, cop_config)
     header = ['Name', 'Default value', 'Configurable values']
-    configs = pars
+    configs = cop_config
               .each_key
               .reject { |key| key.start_with?('Supported') }
               .reject { |key| key.start_with?('AllowMultipleStyles') }
+    return '' if configs.empty?
+
     content = configs.map do |name|
-      configurable = configurable_values(pars, name)
-      default = format_table_value(pars[name])
+      configurable = configurable_values(cop_config, name)
+      default = format_table_value(cop_config[name])
 
       [configuration_name(department, name), default, configurable]
     end
@@ -198,17 +206,17 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   end
 
   # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
-  def configurable_values(pars, name)
+  def configurable_values(cop_config, name)
     case name
     when /^Enforced/
       supported_style_name = RuboCop::Cop::Util.to_supported_styles(name)
-      format_table_value(pars[supported_style_name])
+      format_table_value(cop_config[supported_style_name])
     when 'IndentationWidth'
       'Integer'
     when 'Database'
-      format_table_value(pars['SupportedDatabases'])
+      format_table_value(cop_config['SupportedDatabases'])
     else
-      case pars[name]
+      case cop_config[name]
       when String
         'String'
       when Integer
@@ -311,7 +319,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
       AutoCorrect Description Enabled StyleGuide Reference Safe SafeAutoCorrect VersionAdded
       VersionChanged
     ]
-    pars = cop_config.reject { |k| non_display_keys.include? k }
+    parameters = cop_config.reject { |k| non_display_keys.include? k }
     description = 'No documentation'
     example_objects = safety_objects = see_objects = []
     cop_code(cop) do |code_object|
@@ -321,7 +329,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
       see_objects = code_object.tags('see')
     end
     data = CopData.new(cop: cop, description: description, example_objects: example_objects,
-                       safety_objects: safety_objects, see_objects: see_objects, config: pars)
+                       safety_objects: safety_objects, see_objects: see_objects, config: parameters)
     cops_body(data)
   end
 

data/lib/rubocop/directive_comment.rb

@@ -88,10 +88,15 @@ module RuboCop
       @cop_names ||= all_cops? ? all_cop_names : parsed_cop_names
     end
 
+    # Returns an array of cops for this directive comment, without resolving departments
+    def raw_cop_names
+      @raw_cop_names ||= (cops || '').split(/,\s*/)
+    end
+
     # Returns array of specified in this directive department names
     # when all department disabled
     def department_names
-      splitted_cops_string.select { |cop| department?(cop) }
+      raw_cop_names.select { |cop| department?(cop) }
     end
 
     # Checks if directive departments include cop
@@ -101,11 +106,11 @@ module RuboCop
 
     # Checks if cop department has already used in directive comment
     def overridden_by_department?(cop)
-      in_directive_department?(cop) && splitted_cops_string.include?(cop)
+      in_directive_department?(cop) && raw_cop_names.include?(cop)
     end
 
     def directive_count
-      splitted_cops_string.count
+      raw_cop_names.count
     end
 
     # Returns line number for directive
@@ -115,12 +120,8 @@ module RuboCop
 
     private
 
-    def splitted_cops_string
-      (cops || '').split(/,\s*/)
-    end
-
     def parsed_cop_names
-      cops = splitted_cops_string.map do |name|
+      cops = raw_cop_names.map do |name|
         department?(name) ? cop_names_for_department(name) : name
       end.flatten
       cops - [LINT_SYNTAX_COP]

data/lib/rubocop/formatter/formatter_set.rb

@@ -77,7 +77,7 @@ module RuboCop
         case formatter_type
         when Class
           formatter_type
-        when /\A[A-Z]/
+        when /\A(::)?[A-Z]/
           custom_formatter_class(formatter_type)
         else
           builtin_formatter_class(formatter_type)

data/lib/rubocop/lsp/diagnostic.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative 'severity'
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Diagnostic for Language Server Protocol of RuboCop.
+    # @api private
+    class Diagnostic
+      def initialize(document_encoding, offense, uri, cop_class)
+        @document_encoding = document_encoding
+        @offense = offense
+        @uri = uri
+        @cop_class = cop_class
+      end
+
+      def to_lsp_code_actions
+        code_actions = []
+
+        code_actions << autocorrect_action if correctable?
+        code_actions << disable_line_action
+
+        code_actions
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def to_lsp_diagnostic(config)
+        highlighted = @offense.highlighted_area
+
+        LanguageServer::Protocol::Interface::Diagnostic.new(
+          message: message,
+          source: 'RuboCop',
+          code: @offense.cop_name,
+          code_description: code_description(config),
+          severity: severity,
+          range: LanguageServer::Protocol::Interface::Range.new(
+            start: LanguageServer::Protocol::Interface::Position.new(
+              line: @offense.line - 1,
+              character: highlighted.begin_pos
+            ),
+            end: LanguageServer::Protocol::Interface::Position.new(
+              line: @offense.line - 1,
+              character: highlighted.end_pos
+            )
+          ),
+          data: {
+            correctable: correctable?,
+            code_actions: to_lsp_code_actions
+          }
+        )
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      private
+
+      def message
+        message = @offense.message
+        message += "\n\nThis offense is not autocorrectable.\n" unless correctable?
+        message
+      end
+
+      def severity
+        Severity.find_by(@offense.severity.name)
+      end
+
+      def code_description(config)
+        return unless @cop_class
+        return unless (doc_url = @cop_class.documentation_url(config))
+
+        LanguageServer::Protocol::Interface::CodeDescription.new(href: doc_url)
+      end
+
+      # rubocop:disable Layout/LineLength, Metrics/MethodLength
+      def autocorrect_action
+        LanguageServer::Protocol::Interface::CodeAction.new(
+          title: "Autocorrect #{@offense.cop_name}",
+          kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
+          edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
+            document_changes: [
+              LanguageServer::Protocol::Interface::TextDocumentEdit.new(
+                text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: ensure_uri_scheme(@uri.to_s).to_s,
+                  version: nil
+                ),
+                edits: correctable? ? offense_replacements : []
+              )
+            ]
+          ),
+          is_preferred: true
+        )
+      end
+      # rubocop:enable Layout/LineLength, Metrics/MethodLength
+
+      # rubocop:disable Metrics/MethodLength
+      def offense_replacements
+        @offense.corrector.as_replacements.map do |range, replacement|
+          LanguageServer::Protocol::Interface::TextEdit.new(
+            range: LanguageServer::Protocol::Interface::Range.new(
+              start: LanguageServer::Protocol::Interface::Position.new(
+                line: range.line - 1,
+                character: range.column
+              ),
+              end: LanguageServer::Protocol::Interface::Position.new(
+                line: range.last_line - 1,
+                character: range.last_column
+              )
+            ),
+            new_text: replacement
+          )
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # rubocop:disable Layout/LineLength, Metrics/MethodLength
+      def disable_line_action
+        LanguageServer::Protocol::Interface::CodeAction.new(
+          title: "Disable #{@offense.cop_name} for this line",
+          kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
+          edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
+            document_changes: [
+              LanguageServer::Protocol::Interface::TextDocumentEdit.new(
+                text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: ensure_uri_scheme(@uri.to_s).to_s,
+                  version: nil
+                ),
+                edits: line_disable_comment
+              )
+            ]
+          )
+        )
+      end
+      # rubocop:enable Layout/LineLength, Metrics/MethodLength
+
+      def line_disable_comment
+        new_text = if @offense.source_line.include?(' # rubocop:disable ')
+                     ",#{@offense.cop_name}"
+                   else
+                     " # rubocop:disable #{@offense.cop_name}"
+                   end
+
+        eol = LanguageServer::Protocol::Interface::Position.new(
+          line: @offense.line - 1,
+          character: length_of_line(@offense.source_line)
+        )
+
+        # TODO: fails for multiline strings - may be preferable to use block
+        # comments to disable some offenses
+        inline_comment = LanguageServer::Protocol::Interface::TextEdit.new(
+          range: LanguageServer::Protocol::Interface::Range.new(start: eol, end: eol),
+          new_text: new_text
+        )
+
+        [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
+
+      def ensure_uri_scheme(uri)
+        uri = URI.parse(uri)
+        uri.scheme = 'file' if uri.scheme.nil?
+        uri
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/logger.rb

@@ -14,8 +14,8 @@ module RuboCop
     # Log for Language Server Protocol of RuboCop.
     # @api private
     class Logger
-      def self.log(message)
-        warn("[server] #{message}")
+      def self.log(message, prefix: '[server]')
+        warn("#{prefix} #{message}")
       end
     end
   end

data/lib/rubocop/lsp/routes.rb

@@ -16,6 +16,11 @@ module RuboCop
     # Routes for Language Server Protocol of RuboCop.
     # @api private
     class Routes
+      CONFIGURATION_FILE_PATTERNS = [
+        RuboCop::ConfigFinder::DOTFILE,
+        RuboCop::CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE
+      ].freeze
+
       def self.handle(name, &block)
         define_method(:"handle_#{name}", &block)
       end
@@ -96,7 +101,7 @@ module RuboCop
 
       handle 'workspace/didChangeWatchedFiles' do |request|
         changed = request[:params][:changes].any? do |change|
-          change[:uri].end_with?(RuboCop::ConfigFinder::DOTFILE)
+          CONFIGURATION_FILE_PATTERNS.any? { |path| change[:uri].end_with?(path) }
         end
 
         if changed
@@ -204,14 +209,12 @@ module RuboCop
 
       def diagnostic(file_uri, text)
         @text_cache[file_uri] = text
-        offenses = @server.offenses(remove_file_protocol_from(file_uri), text)
-        diagnostics = offenses.map { |offense| to_diagnostic(offense) }
 
         {
           method: 'textDocument/publishDiagnostics',
           params: {
             uri: file_uri,
-            diagnostics: diagnostics
+            diagnostics: @server.offenses(remove_file_protocol_from(file_uri), text)
           }
         }
       end
@@ -219,25 +222,6 @@ module RuboCop
       def remove_file_protocol_from(uri)
         uri.delete_prefix('file://')
       end
-
-      def to_diagnostic(offense)
-        code = offense[:cop_name]
-        message = offense[:message]
-        loc = offense[:location]
-        rubocop_severity = offense[:severity]
-        severity = Severity.find_by(rubocop_severity)
-
-        {
-          code: code, message: message, range: to_range(loc), severity: severity, source: 'rubocop'
-        }
-      end
-
-      def to_range(location)
-        {
-          start: { character: location[:start_column] - 1, line: location[:start_line] - 1 },
-          end: { character: location[:last_column], line: location[:last_line] - 1 }
-        }
-      end
     end
   end
 end

data/lib/rubocop/lsp/runtime.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'stringio'
+require_relative 'diagnostic'
+require_relative 'stdin_runner'
 
 #
 # This code is based on https://github.com/standardrb/standard.
@@ -19,24 +20,14 @@ module RuboCop
       attr_writer :safe_autocorrect, :lint_mode, :layout_mode
 
       def initialize(config_store)
-        @config_store = config_store
-        @logged_paths = []
+        @runner = RuboCop::Lsp::StdinRunner.new(config_store)
+        @cop_registry = RuboCop::Cop::Registry.global.to_h
+
         @safe_autocorrect = true
         @lint_mode = false
         @layout_mode = false
       end
 
-      # This abuses the `--stdin` option of rubocop and reads the formatted text
-      # from the `options[:stdin]` that rubocop mutates. This depends on
-      # `parallel: false` as well as the fact that RuboCop doesn't otherwise dup
-      # or reassign that options object. Risky business!
-      #
-      # Reassigning `options[:stdin]` is done here:
-      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cop/team.rb#L131
-      # Printing `options[:stdin]`
-      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cli/command/execute_runner.rb#L95
-      # Setting `parallel: true` would break this here:
-      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/runner.rb#L72
       def format(path, text, command:)
         safe_autocorrect = if command
                              command == 'rubocop.formatAutocorrects'
@@ -44,34 +35,23 @@ module RuboCop
                              @safe_autocorrect
                            end
 
-        formatting_options = {
-          stdin: text, force_exclusion: true, autocorrect: true, safe_autocorrect: safe_autocorrect
-        }
+        formatting_options = { autocorrect: true, safe_autocorrect: safe_autocorrect }
         formatting_options[:only] = config_only_options if @lint_mode || @layout_mode
 
-        redirect_stdout { run_rubocop(formatting_options, path) }
-
-        formatting_options[:stdin]
+        @runner.run(path, text, formatting_options)
+        @runner.formatted_source
       end
 
-      def offenses(path, text)
-        diagnostic_options = {
-          stdin: text, force_exclusion: true, formatters: ['json'], format: 'json'
-        }
+      def offenses(path, text, document_encoding = nil)
+        diagnostic_options = {}
         diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
 
-        json = redirect_stdout { run_rubocop(diagnostic_options, path) }
-        results = JSON.parse(json, symbolize_names: true)
-
-        if results[:files].empty?
-          unless @logged_paths.include?(path)
-            Logger.log "Ignoring file, per configuration: #{path}"
-            @logged_paths << path
-          end
-          return []
+        @runner.run(path, text, diagnostic_options)
+        @runner.offenses.map do |offense|
+          Diagnostic.new(
+            document_encoding, offense, path, @cop_registry[offense.cop_name]&.first
+          ).to_lsp_diagnostic(@runner.config_for_working_directory)
         end
-
-        results.dig(:files, 0, :offenses)
       end
 
       private
@@ -82,20 +62,6 @@ module RuboCop
         only_options << 'Layout' if @layout_mode
         only_options
       end
-
-      def redirect_stdout(&block)
-        stdout = StringIO.new
-
-        RuboCop::Server::Helper.redirect(stdout: stdout, &block)
-
-        stdout.string
-      end
-
-      def run_rubocop(options, path)
-        runner = RuboCop::Runner.new(options, @config_store)
-
-        runner.run([path])
-      end
     end
   end
 end