ruby-lsp 0.23.15 → 0.26.9

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -3,6 +3,7 @@
 
 module RubyLsp
   module ResponseBuilders
+    #: [ResponseType = Interface::SemanticTokens]
     class SemanticHighlighting < ResponseBuilder
       class UndefinedTokenType < StandardError; end
 
@@ -42,11 +43,9 @@ module RubyLsp
         async: 6,
         modification: 7,
         documentation: 8,
-        default_library: 9,
+        defaultLibrary: 9,
       }.freeze #: Hash[Symbol, Integer]
 
-      ResponseType = type_member { { fixed: Interface::SemanticTokens } }
-
       #: ((^(Integer arg0) -> Integer | Prism::CodeUnitsCache) code_units_cache) -> void
       def initialize(code_units_cache)
         super()
@@ -185,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/response_builders/signature_help.rb

@@ -3,9 +3,8 @@
 
 module RubyLsp
   module ResponseBuilders
+    #: [ResponseType = Interface::SignatureHelp?]
     class SignatureHelp < ResponseBuilder
-      ResponseType = type_member { { fixed: T.nilable(Interface::SignatureHelp) } }
-
       #: -> void
       def initialize
         super

data/lib/ruby_lsp/response_builders/test_collection.rb

@@ -3,15 +3,16 @@
 
 module RubyLsp
   module ResponseBuilders
+    #: [ResponseType = Requests::Support::TestItem]
     class TestCollection < ResponseBuilder
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: Requests::Support::TestItem } }
+      #: Array[Interface::CodeLens]
+      attr_reader :code_lens
 
       #: -> void
       def initialize
         super
         @items = {} #: Hash[String, ResponseType]
+        @code_lens = [] #: Array[Interface::CodeLens]
       end
 
       #: (ResponseType item) -> void
@@ -19,6 +20,31 @@ module RubyLsp
         @items[item.id] = item
       end
 
+      #: (ResponseType item) -> void
+      def add_code_lens(item)
+        arguments = [item.uri.to_standardized_path, item.id]
+        start = item.range.start
+        range = Interface::Range.new(
+          start: start,
+          end: Interface::Position.new(line: start.line, character: start.character + 1),
+        )
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          data: { arguments: arguments, kind: "run_test" },
+        )
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          data: { arguments: arguments, kind: "run_test_in_terminal" },
+        )
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          data: { arguments: arguments, kind: "debug_test" },
+        )
+      end
+
       #: (String id) -> ResponseType?
       def [](id)
         @items[id]

data/lib/ruby_lsp/ruby_document.rb

@@ -2,11 +2,8 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  #: [ParseResultType = Prism::ParseLexResult]
   class RubyDocument < Document
-    extend T::Generic
-
-    ParseResultType = type_member { { fixed: Prism::ParseResult } }
-
     METHODS_THAT_CHANGE_DECLARATIONS = [
       :private_constant,
       :attr_reader,
@@ -23,23 +20,13 @@ module RubyLsp
       :private_class_method,
     ].freeze
 
-    class SorbetLevel < T::Enum
-      enums do
-        None = new("none")
-        Ignore = new("ignore")
-        False = new("false")
-        True = new("true")
-        Strict = new("strict")
-      end
-    end
-
     class << self
       #: (Prism::Node node, Integer char_position, code_units_cache: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache), ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
       def locate(node, char_position, code_units_cache:, node_types: [])
         queue = node.child_nodes.compact #: Array[Prism::Node?]
         closest = node
         parent = nil #: Prism::Node?
-        nesting_nodes = [] #: Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] # rubocop:disable Layout/LineLength
+        nesting_nodes = [] #: Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)]
 
         nesting_nodes << node if node.is_a?(Prism::ProgramNode)
         call_node = nil #: Prism::CallNode?
@@ -53,7 +40,7 @@ module RubyLsp
           # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
           # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
           # sibling
-          T.unsafe(queue).unshift(*candidate.child_nodes)
+          queue.unshift(*candidate.child_nodes)
 
           # Skip if the current node doesn't cover the desired position
           loc = candidate.location
@@ -142,11 +129,16 @@ module RubyLsp
       return false unless @needs_parsing
 
       @needs_parsing = false
-      @parse_result = Prism.parse(@source)
+      @parse_result = Prism.parse_lex(@source)
       @code_units_cache = @parse_result.code_units_cache(@encoding)
       true
     end
 
+    #: -> Prism::ProgramNode
+    def ast
+      @parse_result.value.first
+    end
+
     # @override
     #: -> bool
     def syntax_error?
@@ -154,29 +146,9 @@ module RubyLsp
     end
 
     # @override
-    #: -> LanguageId
+    #: -> Symbol
     def language_id
-      LanguageId::Ruby
-    end
-
-    #: -> SorbetLevel
-    def sorbet_level
-      sigil = parse_result.magic_comments.find do |comment|
-        comment.key == "typed"
-      end&.value
-
-      case sigil
-      when "ignore"
-        SorbetLevel::Ignore
-      when "false"
-        SorbetLevel::False
-      when "true"
-        SorbetLevel::True
-      when "strict", "strong"
-        SorbetLevel::Strict
-      else
-        SorbetLevel::None
-      end
+      :ruby
     end
 
     #: (Hash[Symbol, untyped] range, ?node_types: Array[singleton(Prism::Node)]) -> Prism::Node?
@@ -184,7 +156,7 @@ module RubyLsp
       start_position, end_position = find_index_by_position(range[:start], range[:end])
 
       desired_range = (start_position...end_position)
-      queue = @parse_result.value.child_nodes.compact #: Array[Prism::Node?]
+      queue = ast.child_nodes.compact #: Array[Prism::Node?]
 
       until queue.empty?
         candidate = queue.shift
@@ -195,7 +167,7 @@ module RubyLsp
         # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
         # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
         # sibling
-        T.unsafe(queue).unshift(*candidate.child_nodes)
+        queue.unshift(*candidate.child_nodes)
 
         # Skip if the current node doesn't cover the desired position
         loc = candidate.location
@@ -212,7 +184,7 @@ module RubyLsp
       char_position, _ = find_index_by_position(position)
 
       RubyDocument.locate(
-        @parse_result.value,
+        ast,
         char_position,
         code_units_cache: @code_units_cache,
         node_types: node_types,

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)