ruby-lsp 0.23.11 → 0.23.17

data/lib/ruby_lsp/response_builders/test_collection.rb

@@ -4,32 +4,65 @@
 module RubyLsp
   module ResponseBuilders
     class TestCollection < ResponseBuilder
-      class DuplicateIdError < StandardError; end
-
-      extend T::Sig
       extend T::Generic
 
       ResponseType = type_member { { fixed: Requests::Support::TestItem } }
 
-      sig { void }
+      #: Array[Interface::CodeLens]
+      attr_reader :code_lens
+
+      #: -> void
       def initialize
         super
-        @items = T.let({}, T::Hash[String, ResponseType])
+        @items = {} #: Hash[String, ResponseType]
+        @code_lens = [] #: Array[Interface::CodeLens]
       end
 
-      sig { params(item: ResponseType).void }
+      #: (ResponseType item) -> void
       def add(item)
-        raise DuplicateIdError, "TestItem ID is already in use" if @items.key?(item.id)
-
         @items[item.id] = item
       end
 
-      sig { params(id: String).returns(T.nilable(ResponseType)) }
+      #: (ResponseType item) -> void
+      def add_code_lens(item)
+        range = item.range
+        arguments = [item.uri.to_standardized_path, item.id]
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          command: Interface::Command.new(
+            title: "▶ Run",
+            command: "rubyLsp.runTest",
+            arguments: arguments,
+          ),
+        )
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          command: Interface::Command.new(
+            title: "▶ Run In Terminal",
+            command: "rubyLsp.runTestInTerminal",
+            arguments: arguments,
+          ),
+        )
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          command: Interface::Command.new(
+            title: "⚙ Debug",
+            command: "rubyLsp.debugTest",
+            arguments: arguments,
+          ),
+        )
+      end
+
+      #: (String id) -> ResponseType?
       def [](id)
         @items[id]
       end
 
-      sig { override.returns(T::Array[ResponseType]) }
+      # @override
+      #: -> Array[ResponseType]
       def response
         @items.values
       end

data/lib/ruby_lsp/ruby_document.rb

@@ -3,7 +3,6 @@
 
 module RubyLsp
   class RubyDocument < Document
-    extend T::Sig
     extend T::Generic
 
     ParseResultType = type_member { { fixed: Prism::ParseResult } }
@@ -24,49 +23,16 @@ 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
-      extend T::Sig
-
-      sig do
-        params(
-          node: Prism::Node,
-          char_position: Integer,
-          code_units_cache: T.any(
-            T.proc.params(arg0: Integer).returns(Integer),
-            Prism::CodeUnitsCache,
-          ),
-          node_types: T::Array[T.class_of(Prism::Node)],
-        ).returns(NodeContext)
-      end
+      #: (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 = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
+        queue = node.child_nodes.compact #: Array[Prism::Node?]
         closest = node
-        parent = T.let(nil, T.nilable(Prism::Node))
-        nesting_nodes = T.let(
-          [],
-          T::Array[T.any(
-            Prism::ClassNode,
-            Prism::ModuleNode,
-            Prism::SingletonClassNode,
-            Prism::DefNode,
-            Prism::BlockNode,
-            Prism::LambdaNode,
-            Prism::ProgramNode,
-          )],
-        )
+        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 << node if node.is_a?(Prism::ProgramNode)
-        call_node = T.let(nil, T.nilable(Prism::CallNode))
+        call_node = nil #: Prism::CallNode?
 
         until queue.empty?
           candidate = queue.shift
@@ -77,7 +43,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
@@ -150,24 +116,18 @@ module RubyLsp
       end
     end
 
-    sig do
-      returns(T.any(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
-    end
+    #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     attr_reader :code_units_cache
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
       super
-      @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
+      @code_units_cache = @parse_result
+        .code_units_cache(@encoding) #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def parse!
       return false unless @needs_parsing
 
@@ -177,47 +137,24 @@ module RubyLsp
       true
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def syntax_error?
       @parse_result.failure?
     end
 
-    sig { override.returns(LanguageId) }
+    # @override
+    #: -> Symbol
     def language_id
-      LanguageId::Ruby
+      :ruby
     end
 
-    sig { returns(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
-    end
-
-    sig do
-      params(
-        range: T::Hash[Symbol, T.untyped],
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns(T.nilable(Prism::Node))
-    end
+    #: (Hash[Symbol, untyped] range, ?node_types: Array[singleton(Prism::Node)]) -> Prism::Node?
     def locate_first_within_range(range, node_types: [])
       start_position, end_position = find_index_by_position(range[:start], range[:end])
 
       desired_range = (start_position...end_position)
-      queue = T.let(@parse_result.value.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
+      queue = @parse_result.value.child_nodes.compact #: Array[Prism::Node?]
 
       until queue.empty?
         candidate = queue.shift
@@ -228,7 +165,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
@@ -240,12 +177,7 @@ module RubyLsp
       end
     end
 
-    sig do
-      params(
-        position: T::Hash[Symbol, T.untyped],
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns(NodeContext)
-    end
+    #: (Hash[Symbol, untyped] position, ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
     def locate_node(position, node_types: [])
       char_position, _ = find_index_by_position(position)
 
@@ -257,7 +189,7 @@ module RubyLsp
       )
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def should_index?
       # This method controls when we should index documents. If there's no recent edit and the document has just been
       # opened, we need to index it
@@ -268,7 +200,7 @@ module RubyLsp
 
     private
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def last_edit_may_change_declarations?
       case @last_edit
       when Delete
@@ -282,7 +214,7 @@ module RubyLsp
       end
     end
 
-    sig { params(position: T::Hash[Symbol, Integer]).returns(T::Boolean) }
+    #: (Hash[Symbol, Integer] position) -> bool
     def position_may_impact_declarations?(position)
       node_context = locate_node(position)
       node_at_edit = node_context.node

data/lib/ruby_lsp/scope.rb

@@ -3,26 +3,24 @@
 
 module RubyLsp
   class Scope
-    extend T::Sig
-
-    sig { returns(T.nilable(Scope)) }
+    #: Scope?
     attr_reader :parent
 
-    sig { params(parent: T.nilable(Scope)).void }
+    #: (?Scope? parent) -> void
     def initialize(parent = nil)
       @parent = parent
 
       # A hash of name => type
-      @locals = T.let({}, T::Hash[Symbol, Local])
+      @locals = {} #: Hash[Symbol, Local]
     end
 
     # Add a new local to this scope. The types should only be `:parameter` or `:variable`
-    sig { params(name: T.any(String, Symbol), type: Symbol).void }
+    #: ((String | Symbol) name, Symbol type) -> void
     def add(name, type)
       @locals[name.to_sym] = Local.new(type)
     end
 
-    sig { params(name: T.any(String, Symbol)).returns(T.nilable(Local)) }
+    #: ((String | Symbol) name) -> Local?
     def lookup(name)
       sym = name.to_sym
       entry = @locals[sym]
@@ -33,12 +31,10 @@ module RubyLsp
     end
 
     class Local
-      extend T::Sig
-
-      sig { returns(Symbol) }
+      #: Symbol
       attr_reader :type
 
-      sig { params(type: Symbol).void }
+      #: (Symbol type) -> void
       def initialize(type)
         @type = type
       end

data/lib/ruby_lsp/scripts/compose_bundle.rb

@@ -13,8 +13,10 @@ def compose(raw_initialize)
   workspace_path ||= Dir.pwd
 
   env = RubyLsp::SetupBundler.new(workspace_path, launcher: true).setup!
-  File.write(
-    File.join(".ruby-lsp", "bundle_env"),
-    env.map { |k, v| "#{k}=#{v}" }.join("\n"),
-  )
+
+  File.open(File.join(".ruby-lsp", "bundle_env"), "w") do |f|
+    f.flock(File::LOCK_EX)
+    f.write(env.map { |k, v| "#{k}=#{v}" }.join("\n"))
+    f.flush
+  end
 end