rubocop 1.53.0 → 1.90.0

data/lib/rubocop/lockfile.rb

@@ -1,18 +1,39 @@
 # frozen_string_literal: true
 
+begin
+  # We might not be running with `bundle exec`, so we need to pull in Bundler ourselves,
+  # in order to use `Bundler::LockfileParser`.
+  require 'bundler'
+rescue LoadError
+  nil
+end
+
 module RuboCop
   # Encapsulation of a lockfile for use when checking for gems.
   # Does not actually resolve gems, just parses the lockfile.
   # @api private
   class Lockfile
-    # Gems that the bundle depends on
+    # @param [String, Pathname, nil] lockfile_path
+    def initialize(lockfile_path = nil)
+      lockfile_path ||= begin
+        ::Bundler.default_lockfile if use_bundler_lock_parser?
+      rescue ::Bundler::GemfileNotFound
+        nil # We might not be a folder with a Gemfile, but that's okay.
+      end
+
+      @lockfile_path = lockfile_path
+    end
+
+    # Gems that the bundle directly depends on.
+    # @return [Array<Bundler::Dependency>, nil]
     def dependencies
       return [] unless parser
 
       parser.dependencies.values
     end
 
-    # All activated gems, including transitive dependencies
+    # All activated gems, including transitive dependencies.
+    # @return [Array<Bundler::Dependency>, nil]
     def gems
       return [] unless parser
 
@@ -21,20 +42,68 @@ module RuboCop
       parser.dependencies.values.concat(parser.specs.flat_map(&:dependencies))
     end
 
+    # Returns the locked versions of gems from this lockfile.
+    # @param [Boolean] include_transitive_dependencies: When false, only direct dependencies
+    #   are returned, i.e. those listed explicitly in the `Gemfile`.
+    # @returns [Hash{String => Gem::Version}] The locked gem versions, keyed by the gems' names.
+    def gem_versions(include_transitive_dependencies: true)
+      return {} unless parser
+
+      all_gem_versions = parser.specs.to_h { |spec| [spec.name, spec.version] }
+
+      if include_transitive_dependencies
+        all_gem_versions
+      else
+        direct_dep_names = parser.dependencies.keys
+        all_gem_versions.slice(*direct_dep_names)
+      end
+    end
+
+    # Names of gems sourced from a local path, i.e. `path:` dependencies and the
+    # project's own gem when the `Gemfile` uses `gemspec`. Git sources are not
+    # included: their code lives outside the project, like a released gem's.
+    # @return [Array<String>]
+    def path_sourced_gem_names
+      return [] unless parser
+
+      parser.specs.filter_map do |spec|
+        spec.name if path_source?(spec.source)
+      end
+    end
+
+    # Whether this lockfile includes the named gem, directly or indirectly.
+    # @param [String] name
+    # @return [Boolean]
     def includes_gem?(name)
       gems.any? { |gem| gem.name == name }
     end
 
     private
 
+    # `Bundler::Source::Git` is a subclass of `Bundler::Source::Path`, but a git
+    # source is a remote one.
+    def path_source?(source)
+      source.is_a?(::Bundler::Source::Path) && !source.is_a?(::Bundler::Source::Git)
+    end
+
+    # @return [Bundler::LockfileParser, nil]
     def parser
-      return unless defined?(Bundler) && Bundler.default_lockfile
       return @parser if defined?(@parser)
 
-      lockfile = Bundler.read_file(Bundler.default_lockfile)
-      @parser = lockfile ? Bundler::LockfileParser.new(lockfile) : nil
-    rescue Bundler::BundlerError
-      nil
+      @parser = if @lockfile_path && File.exist?(@lockfile_path) && use_bundler_lock_parser?
+                  begin
+                    lockfile = ::Bundler.read_file(@lockfile_path)
+                    ::Bundler::LockfileParser.new(lockfile) if lockfile
+                  rescue ::Bundler::BundlerError
+                    nil
+                  end
+                end
+    end
+
+    def use_bundler_lock_parser?
+      return false unless Object.const_defined?(:Bundler)
+
+      Bundler.const_defined?(:LockfileParser) && Bundler::VERSION >= '2.0'
     end
   end
 end

data/lib/rubocop/lsp/diagnostic.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'language_server-protocol'
+require_relative 'disable_comment_edits'
+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, processed_source = nil)
+        @document_encoding = document_encoding
+        @offense = offense
+        @uri = uri
+        @cop_class = cop_class
+        @processed_source = processed_source
+      end
+
+      def to_lsp_code_actions
+        code_actions = []
+
+        code_actions << autocorrect_action if correctable?
+        code_actions << disable_line_action
+
+        code_actions
+      end
+
+      # rubocop:disable-next 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: to_position_character(highlighted.begin_pos)
+            ),
+            end: LanguageServer::Protocol::Interface::Position.new(
+              line: @offense.line - 1,
+              character: to_position_character(highlighted.end_pos)
+            )
+          ),
+          data: {
+            correctable: correctable?,
+            code_actions: to_lsp_code_actions
+          }
+        )
+      end
+
+      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-next 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:disable-next 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: to_position_character(range.column)
+              ),
+              end: LanguageServer::Protocol::Interface::Position.new(
+                line: range.last_line - 1,
+                character: to_position_character(range.last_column)
+              )
+            ),
+            new_text: replacement
+          )
+        end
+      end
+
+      # rubocop:disable-next 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
+
+      def line_disable_comment
+        DisableCommentEdits.new(
+          offense: @offense,
+          document_encoding: @document_encoding,
+          processed_source: @processed_source
+        ).edits
+      end
+
+      def to_position_character(utf8_index)
+        str = @offense.source_line[0, utf8_index]
+        if @document_encoding == Encoding::UTF_16LE || @document_encoding.nil?
+          str.length + str.b.count("\xf0-\xff".b)
+        else
+          str.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/disable_comment_edits.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module LSP
+    # Builds LSP text edits for rubocop:disable comments.
+    # @api private
+    class DisableCommentEdits
+      def initialize(offense:, document_encoding:, processed_source:)
+        @offense = offense
+        @document_encoding = document_encoding
+        @processed_source = processed_source
+      end
+
+      def edits
+        literal_range = multiline_literal_range
+        return block_disable_comments(literal_range) if literal_range
+
+        inline_disable_comment
+      end
+
+      private
+
+      def inline_disable_comment
+        eol = position(@offense.line - 1, @offense.source_line.length, @offense.source_line)
+        [text_edit(eol, inline_comment_text)]
+      end
+
+      def inline_comment_text
+        if @offense.source_line.include?(' # rubocop:disable ')
+          ",#{@offense.cop_name}"
+        else
+          " # rubocop:disable #{@offense.cop_name}"
+        end
+      end
+
+      def block_disable_comments(range)
+        full_line_range = range_by_lines(range)
+        leading_whitespace = full_line_range.source_line[/^\s*/].to_s
+        [
+          disable_edit(full_line_range.first_line, leading_whitespace),
+          enable_edit(full_line_range, leading_whitespace)
+        ]
+      end
+
+      def disable_edit(first_line, leading_whitespace)
+        position = position(first_line - 1, 0, '')
+        text_edit(position, "#{leading_whitespace}# rubocop:disable #{@offense.cop_name}\n")
+      end
+
+      def enable_edit(full_line_range, leading_whitespace)
+        last_line = full_line_range.last_line
+        last_line_text = full_line_range.source_buffer.source_line(last_line)
+        position = position(last_line - 1, last_line_text.length, last_line_text)
+        text_edit(position, "\n#{leading_whitespace}# rubocop:enable #{@offense.cop_name}")
+      end
+
+      def text_edit(position, new_text)
+        range = LanguageServer::Protocol::Interface::Range.new(start: position, end: position)
+        LanguageServer::Protocol::Interface::TextEdit.new(range: range, new_text: new_text)
+      end
+
+      def position(line, utf8_index, line_text)
+        LanguageServer::Protocol::Interface::Position.new(
+          line: line,
+          character: position_character(utf8_index, line_text)
+        )
+      end
+
+      def position_character(utf8_index, line_text)
+        str = line_text[0, utf8_index]
+        if @document_encoding == Encoding::UTF_16LE || @document_encoding.nil?
+          str.length + str.b.count("\xf0-\xff".b)
+        else
+          str.length
+        end
+      end
+
+      def multiline_literal_range
+        return unless @processed_source&.ast
+
+        offense_range = @offense.location
+        multiline_ranges&.find do |range|
+          eol_comment_would_be_inside_literal?(offense_range, range)
+        end
+      end
+
+      def multiline_ranges
+        @processed_source.ast.each_node.filter_map do |node|
+          if surrounding_heredoc?(node)
+            heredoc_range(node)
+          elsif string_continuation?(node)
+            range_by_lines(node.source_range)
+          elsif surrounding_percent_array?(node) || multiline_string?(node)
+            node.source_range
+          end
+        end
+      end
+
+      def eol_comment_would_be_inside_literal?(offense_range, literal_range)
+        offense_line = offense_range.line
+        offense_line >= literal_range.first_line && offense_line < literal_range.last_line
+      end
+
+      def surrounding_heredoc?(node)
+        node.any_str_type? && node.heredoc?
+      end
+
+      def heredoc_range(node)
+        node.source_range.join(node.loc.heredoc_end)
+      end
+
+      def surrounding_percent_array?(node)
+        node.array_type? && node.percent_literal?
+      end
+
+      def string_continuation?(node)
+        node.any_str_type? && node.source.match?(/\\\s*$/)
+      end
+
+      def multiline_string?(node)
+        node.dstr_type? && node.multiline?
+      end
+
+      def range_by_lines(range)
+        begin_of_first_line = range.begin_pos - range.column
+
+        last_line = range.source_buffer.source_line(range.last_line)
+        last_line_offset = last_line.length - range.last_column
+        end_of_last_line = range.end_pos + last_line_offset
+
+        Parser::Source::Range.new(range.source_buffer, begin_of_first_line, end_of_last_line)
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/logger.rb

@@ -10,12 +10,12 @@
 # https://github.com/standardrb/standard/blob/main/LICENSE.txt
 #
 module RuboCop
-  module Lsp
+  module LSP
     # 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