ruby-lsp 0.26.2 → 0.26.9

data/lib/ruby_lsp/requests/support/package_url.rb

@@ -0,0 +1,414 @@
+# typed: false
+# frozen_string_literal: true
+
+# This is a copy of the implementation from the `package_url` gem with the
+# following license. Original source can be found at:
+# https://github.com/package-url/packageurl-ruby/blob/main/lib/package_url.rb
+
+# MIT License
+#
+# Copyright (c) 2021 package-url
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+require "uri"
+
+# A package URL, or _purl_, is a URL string used to
+# identify and locate a software package in a mostly universal and uniform way
+# across programing languages, package managers, packaging conventions, tools,
+# APIs and databases.
+#
+# A purl is a URL composed of seven components:
+#
+# ```
+# scheme:type/namespace/name@version?qualifiers#subpath
+# ```
+#
+# For example,
+# the package URL for this Ruby package at version 0.1.0 is
+# `pkg:ruby/mattt/packageurl-ruby@0.1.0`.
+module RubyLsp
+  class PackageURL
+    # Raised when attempting to parse an invalid package URL string.
+    # @see #parse
+    class InvalidPackageURL < ArgumentError; end
+
+    # The URL scheme, which has a constant value of `"pkg"`.
+    def scheme
+      "pkg"
+    end
+
+    # The package type or protocol, such as `"gem"`, `"npm"`, and `"github"`.
+    attr_reader :type
+
+    # A name prefix, specific to the type of package.
+    # For example, an npm scope, a Docker image owner, or a GitHub user.
+    attr_reader :namespace
+
+    # The name of the package.
+    attr_reader :name
+
+    # The version of the package.
+    attr_reader :version
+
+    # Extra qualifying data for a package, specific to the type of package.
+    # For example, the operating system or architecture.
+    attr_reader :qualifiers
+
+    # An extra subpath within a package, relative to the package root.
+    attr_reader :subpath
+
+    # Constructs a package URL from its components
+    # @param type [String] The package type or protocol.
+    # @param namespace [String] A name prefix, specific to the type of package.
+    # @param name [String] The name of the package.
+    # @param version [String] The version of the package.
+    # @param qualifiers [Hash] Extra qualifying data for a package, specific to the type of package.
+    # @param subpath [String] An extra subpath within a package, relative to the package root.
+    def initialize(type:, name:, namespace: nil, version: nil, qualifiers: nil, subpath: nil)
+      raise ArgumentError, "type is required" if type.nil? || type.empty?
+      raise ArgumentError, "name is required" if name.nil? || name.empty?
+
+      @type = type.downcase
+      @namespace = namespace
+      @name = name
+      @version = version
+      @qualifiers = qualifiers
+      @subpath = subpath
+    end
+
+    # Creates a new PackageURL from a string.
+    # @param [String] string The package URL string.
+    # @raise [InvalidPackageURL] If the string is not a valid package URL.
+    # @return [PackageURL]
+    def self.parse(string)
+      components = {
+        type: nil,
+        namespace: nil,
+        name: nil,
+        version: nil,
+        qualifiers: nil,
+        subpath: nil,
+      }
+
+      # Split the purl string once from right on '#'
+      # - The left side is the remainder
+      # - Strip the right side from leading and trailing '/'
+      # - Split this on '/'
+      # - Discard any empty string segment from that split
+      # - Discard any '.' or '..' segment from that split
+      # - Percent-decode each segment
+      # - UTF-8-decode each segment if needed in your programming language
+      # - Join segments back with a '/'
+      # - This is the subpath
+      case string.rpartition("#")
+      in String => remainder, separator, String => subpath unless separator.empty?
+        subpath_components = []
+        subpath.split("/").each do |segment|
+          next if segment.empty? || segment == "." || segment == ".."
+
+          subpath_components << URI.decode_www_form_component(segment)
+        end
+
+        components[:subpath] = subpath_components.compact.join("/")
+
+        string = remainder
+      else
+        components[:subpath] = nil
+      end
+
+      # Split the remainder once from right on '?'
+      # - The left side is the remainder
+      # - The right side is the qualifiers string
+      # - Split the qualifiers on '&'. Each part is a key=value pair
+      # - For each pair, split the key=value once from left on '=':
+      # - The key is the lowercase left side
+      # - The value is the percent-decoded right side
+      # - UTF-8-decode the value if needed in your programming language
+      # - Discard any key/value pairs where the value is empty
+      # - If the key is checksums,
+      #   split the value on ',' to create a list of checksums
+      # - This list of key/value is the qualifiers object
+      case string.rpartition("?")
+      in String => remainder, separator, String => qualifiers unless separator.empty?
+        components[:qualifiers] = {}
+
+        qualifiers.split("&").each do |pair|
+          case pair.partition("=")
+          in String => key, separator, String => value unless separator.empty?
+            key = key.downcase
+            value = URI.decode_www_form_component(value)
+            next if value.empty?
+
+            components[:qualifiers][key] = case key
+            when "checksums"
+              value.split(",")
+            else
+              value
+            end
+          else
+            next
+          end
+        end
+
+        string = remainder
+      else
+        components[:qualifiers] = nil
+      end
+
+      # Split the remainder once from left on ':'
+      # - The left side lowercased is the scheme
+      # - The right side is the remainder
+      case string.partition(":")
+      in "pkg", separator, String => remainder unless separator.empty?
+        string = remainder
+      else
+        raise InvalidPackageURL, 'invalid or missing "pkg:" URL scheme'
+      end
+
+      # Strip the remainder from leading and trailing '/'
+      # Use gsub to remove ALL leading slashes instead of just one
+      string = string.gsub(%r{^/+}, "").delete_suffix("/")
+      # - Split this once from left on '/'
+      # - The left side lowercased is the type
+      # - The right side is the remainder
+      case string.partition("/")
+      in String => type, separator, remainder unless separator.empty?
+        components[:type] = type
+
+        string = remainder
+      else
+        raise InvalidPackageURL, "invalid or missing package type"
+      end
+
+      # Split the remainder once from right on '@'
+      # - The left side is the remainder
+      # - Percent-decode the right side. This is the version.
+      # - UTF-8-decode the version if needed in your programming language
+      # - This is the version
+      case string.rpartition("@")
+      in String => remainder, separator, String => version unless separator.empty?
+        components[:version] = URI.decode_www_form_component(version)
+
+        string = remainder
+      else
+        components[:version] = nil
+      end
+
+      # Split the remainder once from right on '/'
+      # - The left side is the remainder
+      # - Percent-decode the right side. This is the name
+      # - UTF-8-decode this name if needed in your programming language
+      # - Apply type-specific normalization to the name if needed
+      # - This is the name
+      case string.rpartition("/")
+      in String => remainder, separator, String => name unless separator.empty?
+        components[:name] = URI.decode_www_form_component(name)
+
+        # Split the remainder on '/'
+        # - Discard any empty segment from that split
+        # - Percent-decode each segment
+        # - UTF-8-decode the each segment if needed in your programming language
+        # - Apply type-specific normalization to each segment if needed
+        # - Join segments back with a '/'
+        # - This is the namespace
+        components[:namespace] = remainder.split("/").map { |s| URI.decode_www_form_component(s) }.compact.join("/")
+      in _, _, String => name
+        components[:name] = URI.decode_www_form_component(name)
+        components[:namespace] = nil
+      end
+
+      # Ensure type and name are not nil before creating the PackageURL instance
+      raise InvalidPackageURL, "missing package type" if components[:type].nil?
+      raise InvalidPackageURL, "missing package name" if components[:name].nil?
+
+      # Create a new PackageURL with validated components
+      type = components[:type] || ""  # This ensures type is never nil
+      name = components[:name] || ""  # This ensures name is never nil
+
+      new(
+        type: type,
+        name: name,
+        namespace: components[:namespace],
+        version: components[:version],
+        qualifiers: components[:qualifiers],
+        subpath: components[:subpath],
+      )
+    end
+
+    # Returns a hash containing the
+    # scheme, type, namespace, name, version, qualifiers, and subpath components
+    # of the package URL.
+    def to_h
+      {
+        scheme: scheme,
+        type: @type,
+        namespace: @namespace,
+        name: @name,
+        version: @version,
+        qualifiers: @qualifiers,
+        subpath: @subpath,
+      }
+    end
+
+    # Returns a string representation of the package URL.
+    # Package URL representations are created according to the instructions from
+    # https://github.com/package-url/purl-spec/blob/0b1559f76b79829e789c4f20e6d832c7314762c5/PURL-SPECIFICATION.rst#how-to-build-purl-string-from-its-components.
+    def to_s
+      # Start a purl string with the "pkg:" scheme as a lowercase ASCII string
+      purl = "pkg:"
+
+      # Append the type string to the purl as a lowercase ASCII string
+      # Append '/' to the purl
+
+      purl += @type
+      purl += "/"
+
+      # If the namespace is not empty:
+      # - Strip the namespace from leading and trailing '/'
+      # - Split on '/' as segments
+      # - Apply type-specific normalization to each segment if needed
+      # - UTF-8-encode each segment if needed in your programming language
+      # - Percent-encode each segment
+      # - Join the segments with '/'
+      # - Append this to the purl
+      # - Append '/' to the purl
+      # - Strip the name from leading and trailing '/'
+      # - Apply type-specific normalization to the name if needed
+      # - UTF-8-encode the name if needed in your programming language
+      # - Append the percent-encoded name to the purl
+      #
+      # If the namespace is empty:
+      # - Apply type-specific normalization to the name if needed
+      # - UTF-8-encode the name if needed in your programming language
+      # - Append the percent-encoded name to the purl
+      case @namespace
+      in String => namespace unless namespace.empty?
+        segments = []
+        @namespace.delete_prefix("/").delete_suffix("/").split("/").each do |segment|
+          next if segment.empty?
+
+          segments << URI.encode_www_form_component(segment)
+        end
+        purl += segments.join("/")
+
+        purl += "/"
+        purl += URI.encode_www_form_component(@name.delete_prefix("/").delete_suffix("/"))
+      else
+        purl += URI.encode_www_form_component(@name)
+      end
+
+      # If the version is not empty:
+      # - Append '@' to the purl
+      # - UTF-8-encode the version if needed in your programming language
+      # - Append the percent-encoded version to the purl
+      case @version
+      in String => version unless version.empty?
+        purl += "@"
+        purl += URI.encode_www_form_component(@version)
+      else
+        nil
+      end
+
+      # If the qualifiers are not empty and not composed only of key/value pairs
+      # where the value is empty:
+      # - Append '?' to the purl
+      # - Build a list from all key/value pair:
+      # - discard any pair where the value is empty.
+      # - UTF-8-encode each value if needed in your programming language
+      # - If the key is checksums and this is a list of checksums
+      #   join this list with a ',' to create this qualifier value
+      # - create a string by joining the lowercased key,
+      #   the equal '=' sign and the percent-encoded value to create a qualifier
+      # - sort this list of qualifier strings lexicographically
+      # - join this list of qualifier strings with a '&' ampersand
+      # - Append this string to the purl
+      case @qualifiers
+      in Hash => qualifiers unless qualifiers.empty?
+        list = []
+        qualifiers.each do |key, value|
+          next if value.empty?
+
+          list << case [key, value]
+          in "checksums", Array => checksums
+            "#{key.downcase}=#{checksums.join(",")}"
+          else
+            "#{key.downcase}=#{URI.encode_www_form_component(value)}"
+          end
+        end
+
+        unless list.empty?
+          purl += "?"
+          purl += list.sort.join("&")
+        end
+      else
+        nil
+      end
+
+      # If the subpath is not empty and not composed only of
+      # empty, '.' and '..' segments:
+      # - Append '#' to the purl
+      # - Strip the subpath from leading and trailing '/'
+      # - Split this on '/' as segments
+      # - Discard empty, '.' and '..' segments
+      # - Percent-encode each segment
+      # - UTF-8-encode each segment if needed in your programming language
+      # - Join the segments with '/'
+      # - Append this to the purl
+      case @subpath
+      in String => subpath unless subpath.empty?
+        segments = []
+        subpath.delete_prefix("/").delete_suffix("/").split("/").each do |segment|
+          next if segment.empty? || segment == "." || segment == ".."
+
+          # Custom encoding for URL fragment segments:
+          # 1. Explicitly encode % as %25 to prevent double-encoding issues
+          # 2. Percent-encode special characters according to URL fragment rules
+          # 3. This ensures proper round-trip encoding/decoding with the parse method
+          segments << segment.gsub(/%|[^A-Za-z0-9\-\._~]/) do |m|
+            m == "%" ? "%25" : format("%%%02X", m.ord)
+          end
+        end
+
+        unless segments.empty?
+          purl += "#"
+          purl += segments.join("/")
+        end
+      else
+        nil
+      end
+
+      purl
+    end
+
+    # Returns an array containing the
+    # scheme, type, namespace, name, version, qualifiers, and subpath components
+    # of the package URL.
+    def deconstruct
+      [scheme, @type, @namespace, @name, @version, @qualifiers, @subpath]
+    end
+
+    # Returns a hash containing the
+    # scheme, type, namespace, name, version, qualifiers, and subpath components
+    # of the package URL.
+    def deconstruct_keys(_keys)
+      to_h
+    end
+  end
+end

data/lib/ruby_lsp/requests/support/rubocop_diagnostic.rb

@@ -14,6 +14,12 @@ module RubyLsp
           fatal: Constant::DiagnosticSeverity::ERROR,
         }.freeze #: Hash[Symbol, Integer]
 
+        # Cops where adding a `rubocop:disable` inline comment would itself resolve the offense,
+        # causing Lint/RedundantCopDisableDirective to flag the disable as unnecessary.
+        SELF_RESOLVING_DISABLE_COPS = Set.new([
+          "Layout/EmptyComment",
+        ]).freeze #: Set[String]
+
         ENHANCED_DOC_URL = begin
           gem("rubocop", ">= 1.64.0")
           true
@@ -35,7 +41,7 @@ module RubyLsp
           code_actions = []
 
           code_actions << autocorrect_action if correctable?
-          code_actions << disable_line_action
+          code_actions << disable_line_action unless SELF_RESOLVING_DISABLE_COPS.include?(@offense.cop_name)
 
           code_actions
         end

data/lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -61,14 +61,6 @@ module RubyLsp
           "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
         ] #: Array[String]
 
-        # Functionality was introduced in 1.75.0 but had issues with autocorrect
-        REUSE_PRISM_RESULT = begin
-          gem("rubocop", ">= 1.80.1")
-          true
-        rescue LoadError
-          false
-        end #: bool
-
         #: Array[::RuboCop::Cop::Offense]
         attr_reader :offenses
 
@@ -89,7 +81,7 @@ module RubyLsp
           @offenses = [] #: Array[::RuboCop::Cop::Offense]
           @errors = [] #: Array[String]
           @warnings = [] #: Array[String]
-          @prism_result = nil #: Prism::ParseLexResult?
+          # @prism_result = nil #: Prism::ParseLexResult?
 
           args += DEFAULT_ARGS
           rubocop_options = ::RuboCop::Options.new.parse(args).first
@@ -109,7 +101,11 @@ module RubyLsp
           @warnings = []
           @offenses = []
           @options[:stdin] = contents
-          @prism_result = prism_result if REUSE_PRISM_RESULT
+
+          # Setting the Prism result before running the RuboCop runner makes it reuse the existing AST and avoids
+          # double-parsing. Unfortunately, this leads to a bunch of cops failing to execute properly under LSP mode.
+          # Uncomment this once reusing the Prism result is more stable
+          # @prism_result = prism_result
 
           super([path])
 

data/lib/ruby_lsp/requests/support/source_uri.rb

@@ -5,6 +5,7 @@ require "uri/file"
 
 module URI
   # Must be kept in sync with the one in Tapioca
+  # https://github.com/Shopify/tapioca/blob/main/lib/tapioca/helpers/source_uri.rb
   class Source < URI::File
     COMPONENT = [
       :scheme,
@@ -21,16 +22,14 @@ module URI
     # have the uri gem in their own bundle and thus not use a compatible version.
     PARSER = const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER #: RFC2396_Parser
 
-    self #: as untyped # rubocop:disable Style/RedundantSelf
-      .alias_method(:gem_name, :host)
-    self #: as untyped # rubocop:disable Style/RedundantSelf
-      .alias_method(:line_number, :fragment)
+    alias_method(:gem_name, :host)
+    alias_method(:line_number, :fragment)
 
     #: String?
     attr_reader :gem_version
 
     class << self
-      #: (gem_name: String, gem_version: String?, path: String, line_number: String?) -> URI::Source
+      #: (gem_name: String, gem_version: String?, path: String, line_number: String?) -> instance
       def build(gem_name:, gem_version:, path:, line_number:)
         super(
           {
@@ -67,12 +66,14 @@ module URI
 
     #: -> String
     def to_s
-      "source://#{gem_name}/#{gem_version}#{path}##{line_number}"
+      "source://#{gem_name}/#{gem_version}/#{path}##{line_number}"
     end
 
     if URI.respond_to?(:register_scheme)
+      # Handle URI 0.11.0 and newer https://github.com/ruby/uri/pull/26
       URI.register_scheme("SOURCE", self)
     else
+      # Fallback for URI <0.11.0
       @@schemes = @@schemes #: Hash[String, untyped] # rubocop:disable Style/ClassVars
       @@schemes["SOURCE"] = self
     end

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -20,17 +20,7 @@ module RubyLsp
       # @override
       #: -> Array[Interface::WorkspaceSymbol]
       def perform
-        @index.fuzzy_search(@query).filter_map do |entry|
-          uri = entry.uri
-          file_path = uri.full_path
-
-          # We only show symbols declared in the workspace
-          in_dependencies = file_path && !not_in_dependencies?(file_path)
-          next if in_dependencies
-
-          # We should never show private symbols when searching the entire workspace
-          next if entry.private?
-
+        fuzzy_search.filter_map do |entry|
           kind = kind_for_entry(entry)
           loc = entry.location
 
@@ -44,7 +34,7 @@ module RubyLsp
             container_name: container.join("::"),
             kind: kind,
             location: Interface::Location.new(
-              uri: uri.to_s,
+              uri: entry.uri.to_s,
               range:  Interface::Range.new(
                 start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column),
                 end: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
@@ -53,6 +43,24 @@ module RubyLsp
           )
         end
       end
+
+      private
+
+      #: -> Array[RubyIndexer::Entry]
+      def fuzzy_search
+        @index.fuzzy_search(@query) do |entry|
+          file_path = entry.uri.full_path
+
+          # We only show symbols declared in the workspace
+          in_dependencies = file_path && !not_in_dependencies?(file_path)
+          next if in_dependencies
+
+          # We should never show private symbols when searching the entire workspace
+          next if entry.private?
+
+          true
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -43,7 +43,7 @@ module RubyLsp
         async: 6,
         modification: 7,
         documentation: 8,
-        default_library: 9,
+        defaultLibrary: 9,
       }.freeze #: Hash[Symbol, Integer]
 
       #: ((^(Integer arg0) -> Integer | Prism::CodeUnitsCache) code_units_cache) -> void
@@ -184,8 +184,8 @@ module RubyLsp
         end
 
         # Encode an array of modifiers to positions onto a bit flag
-        # For example, [:default_library] will be encoded as
-        # 0b1000000000, as :default_library is the 10th bit according
+        # For example, [:defaultLibrary] will be encoded as
+        # 0b1000000000, as :defaultLibrary is the 10th bit according
         # to the token modifiers index map.
         #: (Array[Integer] modifiers) -> Integer
         def encode_modifiers(modifiers)

data/lib/ruby_lsp/scripts/compose_bundle.rb

@@ -1,18 +1,18 @@
 # typed: true
 # frozen_string_literal: true
 
-def compose(raw_initialize)
+def compose(raw_initialize, **options)
   require_relative "../setup_bundler"
   require "json"
   require "uri"
-  require "ruby_indexer/lib/ruby_indexer/uri"
+  require_relative "../../ruby_indexer/lib/ruby_indexer/uri"
 
   initialize_request = JSON.parse(raw_initialize, symbolize_names: true)
   workspace_uri = initialize_request.dig(:params, :workspaceFolders, 0, :uri)
   workspace_path = workspace_uri && URI(workspace_uri).to_standardized_path
   workspace_path ||= Dir.pwd
 
-  env = RubyLsp::SetupBundler.new(workspace_path, launcher: true).setup!
+  env = RubyLsp::SetupBundler.new(workspace_path, launcher: true, **options).setup!
 
   File.open(File.join(".ruby-lsp", "bundle_env"), "w") do |f|
     f.flock(File::LOCK_EX)

data/lib/ruby_lsp/scripts/compose_bundle_windows.rb

@@ -5,4 +5,6 @@ require_relative "compose_bundle"
 
 # When this is invoked on Windows, we pass the raw initialize as an argument to this script. On other platforms, we
 # invoke the compose method from inside a forked process
-compose(ARGV.first)
+options = {}
+options[:beta] = true if ARGV.include?("--beta")
+compose(ARGV.first, **options)

data/lib/ruby_lsp/server.rb

@@ -3,6 +3,8 @@
 
 module RubyLsp
   class Server < BaseServer
+    NON_REPORTABLE_SETUP_ERRORS = [Bundler::GemNotFound, Bundler::GitError].freeze #: Array[singleton(StandardError)]
+
     # Only for testing
     #: GlobalState
     attr_reader :global_state
@@ -315,7 +317,7 @@ module RubyLsp
 
       global_state_notifications.each { |notification| send_message(notification) }
 
-      if @setup_error
+      if @setup_error && NON_REPORTABLE_SETUP_ERRORS.none? { |error_class| @setup_error.is_a?(error_class) }
         send_message(Notification.telemetry(
           type: "error",
           errorMessage: @setup_error.message,
@@ -1211,7 +1213,7 @@ module RubyLsp
             }
           end
         end
-      rescue Bundler::GemNotFound, Bundler::GemfileNotFound
+      rescue Bundler::GemNotFound, Bundler::GemfileNotFound, Errno::ENOENT
         []
       end
 
@@ -1436,6 +1438,7 @@ module RubyLsp
             ),
             File.expand_path("../../exe/ruby-lsp-launcher", __dir__),
             @global_state.workspace_uri.to_s,
+            *ARGV,
             chdir: @global_state.workspace_path,
           )
         end