ruby-lsp 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61c8fe2a55057823533a8a17b4472309e3d463ec3d63302fa3393f046ec4b339
-  data.tar.gz: fb9636b8aafac9d5002a872d0f34f7f9852e9348009cdc2934369637a4cadb4c
+  metadata.gz: 437c2048862bed450fd70057489636117c99943dd7bb68df35c4e161a29f8385
+  data.tar.gz: 30d26e8455f9086bc934ffe23b5e37816f18f5904e3422495c316a980a860cfc
 SHA512:
-  metadata.gz: db51fd5526431b773125c0b27bfe8ca53b2861759457f9a36e7a681bcfbffb0f58026b4f8cc4dc991be2380309959aacde7c8cc2cd0a0f0373dfb313d0d28db9
-  data.tar.gz: 13cc3991bffd1a18dd1e2580c8d1051161b03a171a25e8ce681f46fb8d5baedb1de0f9f96304556e08f3db95c2262e29693d22bf3659ba45eff620157adc035c
+  metadata.gz: 366dd4b756ded58762b598545e398059fe0eae7578b13c92cc0a90dcc9aba2d58106dbf2dc0e9867a9db7de5007e6114ebbbf7cf191bcdebb843b077de945ba9
+  data.tar.gz: 1f798c1462825cccafd48bff23baecb8ba8ef36f9b5733502d79c5d8e6e52550c7ab722a99678eec04ce2a8b42c4d84aab912acb2100ff7d26e422b02f2c185b

data/README.md

@@ -123,7 +123,7 @@ To add a new expectations test runner for a new request handler:
 3. [`vscode-ruby-lsp`] Select `Run Extension` and click the green triangle (or press F5).
 4. [`vscode-ruby-lsp`] Now VS Code will:
     - Open another workspace as the `Extension Development Host`.
-    - Run `vscode-ruby-lsp` extension in debug mode, which will start a new `ruby-lsp` process with the `--debug` flag.
+    - Run `vscode-ruby-lsp` extension in debug mode, which will start a new `ruby-lsp` process with the `--debug` flag. Note that debugging is not available on Windows.
 5. Open `ruby-lsp` in VS Code.
 6. [`ruby-lsp`] Run `bin/rdbg -A` to connect to the running `ruby-lsp` process.
 7. [`ruby-lsp`] Use commands like `b <file>:<line>` or `b Class#method` to set breakpoints and type `c` to continue the process.

data/VERSION

@@ -1 +1 @@
-0.4.4
+0.4.5

data/exe/ruby-lsp

@@ -21,6 +21,11 @@ end
 require_relative "../lib/ruby_lsp/internal"
 
 if ARGV.include?("--debug")
+  if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
+    puts "Debugging is not supported on Windows"
+    exit 1
+  end
+
   sockets_dir = "/tmp/ruby-lsp-debug-sockets"
   Dir.mkdir(sockets_dir) unless Dir.exist?(sockets_dir)
   # ruby-debug-ENV["USER"] is an implicit naming pattern in ruby/debug
@@ -28,7 +33,11 @@ if ARGV.include?("--debug")
   socket_identifier = "ruby-debug-#{ENV["USER"]}-#{File.basename(Dir.pwd)}.sock"
   ENV["RUBY_DEBUG_SOCK_PATH"] = "#{sockets_dir}/#{socket_identifier}"
 
-  require "debug/open_nonstop"
+  begin
+    require "debug/open_nonstop"
+  rescue LoadError
+    warn("You need to install the debug gem to use the --debug flag")
+  end
 end
 
 RubyLsp::Server.new.start

data/lib/ruby_lsp/event_emitter.rb

@@ -9,7 +9,7 @@ module RubyLsp
   # - For nonpositional requests, use `visit` to go through the AST, which will fire events for each listener as nodes
   # are found
   #
-  # = Example
+  # # Example
   #
   # ```ruby
   # target_node = document.locate_node(position)
@@ -46,6 +46,8 @@ module RubyLsp
         @event_to_listener_map[:on_call]&.each { |listener| T.unsafe(listener).on_call(node) }
       when SyntaxTree::ConstPathRef
         @event_to_listener_map[:on_const_path_ref]&.each { |listener| T.unsafe(listener).on_const_path_ref(node) }
+      when SyntaxTree::Const
+        @event_to_listener_map[:on_const]&.each { |listener| T.unsafe(listener).on_const(node) }
       end
     end
   end

data/lib/ruby_lsp/executor.rb

@@ -11,7 +11,7 @@ module RubyLsp
       # Requests that mutate the store must be run sequentially! Parallel requests only receive a temporary copy of the
       # store
       @store = store
-      @notifications = T.let([], T::Array[Notification])
+      @messages = T.let([], T::Array[Message])
     end
 
     sig { params(request: T::Hash[Symbol, T.untyped]).returns(Result) }
@@ -25,7 +25,7 @@ module RubyLsp
         error = e
       end
 
-      Result.new(response: response, error: error, request_time: request_time, notifications: @notifications)
+      Result.new(response: response, error: error, request_time: request_time, messages: @messages)
     end
 
     private
@@ -38,6 +38,22 @@ module RubyLsp
       when "initialize"
         initialize_request(request.dig(:params))
       when "initialized"
+        Extension.load_extensions
+
+        errored_extensions = Extension.extensions.select(&:error?)
+
+        if errored_extensions.any?
+          @messages << Notification.new(
+            message: "window/showMessage",
+            params: Interface::ShowMessageParams.new(
+              type: Constant::MessageType::WARNING,
+              message: "Error loading extensions:\n\n#{errored_extensions.map(&:formatted_errors).join("\n\n")}",
+            ),
+          )
+
+          warn(errored_extensions.map(&:backtraces).join("\n\n"))
+        end
+
         warn("Ruby LSP is ready")
         VOID
       when "textDocument/didOpen"
@@ -47,7 +63,7 @@ module RubyLsp
           request.dig(:params, :textDocument, :version),
         )
       when "textDocument/didClose"
-        @notifications << Notification.new(
+        @messages << Notification.new(
           message: "textDocument/publishDiagnostics",
           params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: []),
         )
@@ -75,7 +91,7 @@ module RubyLsp
         begin
           formatting(uri)
         rescue Requests::Formatting::InvalidFormatter => error
-          @notifications << Notification.new(
+          @messages << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -85,7 +101,7 @@ module RubyLsp
 
           nil
         rescue StandardError => error
-          @notifications << Notification.new(
+          @messages << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -111,7 +127,7 @@ module RubyLsp
         begin
           diagnostic(uri)
         rescue StandardError => error
-          @notifications << Notification.new(
+          @messages << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -160,9 +176,16 @@ module RubyLsp
         target = parent
       end
 
-      listener = RubyLsp::Requests::Hover.new
-      EventEmitter.new(listener).emit_for_target(target)
-      listener.response
+      # Instantiate all listeners
+      base_listener = Requests::Hover.new
+      listeners = Requests::Hover.listeners.map(&:new)
+
+      # Emit events for all listeners
+      T.unsafe(EventEmitter).new(base_listener, *listeners).emit_for_target(target)
+
+      # Merge all responses into a single hover
+      listeners.each { |ext| base_listener.merge_response!(ext) }
+      base_listener.response
     end
 
     sig { params(uri: String).returns(T::Array[Interface::DocumentLink]) }
@@ -291,7 +314,7 @@ module RubyLsp
 
       case result
       when Requests::CodeActionResolve::Error::EmptySelection
-        @notifications << Notification.new(
+        @messages << Notification.new(
           message: "window/showMessage",
           params: Interface::ShowMessageParams.new(
             type: Constant::MessageType::ERROR,
@@ -300,7 +323,7 @@ module RubyLsp
         )
         raise Requests::CodeActionResolve::CodeActionError
       when Requests::CodeActionResolve::Error::InvalidTargetRange
-        @notifications << Notification.new(
+        @messages << Notification.new(
           message: "window/showMessage",
           params: Interface::ShowMessageParams.new(
             type: Constant::MessageType::ERROR,

data/lib/ruby_lsp/extension.rb

@@ -0,0 +1,104 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # To register an extension, inherit from this class and implement both `name` and `activate`
+  #
+  # # Example
+  #
+  # ```ruby
+  # module MyGem
+  #   class MyExtension < Extension
+  #     def activate
+  #       # Perform any relevant initialization
+  #     end
+  #
+  #     def name
+  #       "My extension name"
+  #     end
+  #   end
+  # end
+  # ```
+  class Extension
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    class << self
+      extend T::Sig
+
+      # Automatically track and instantiate extension classes
+      sig { params(child_class: T.class_of(Extension)).void }
+      def inherited(child_class)
+        extensions << child_class.new
+        super
+      end
+
+      sig { returns(T::Array[Extension]) }
+      def extensions
+        @extensions ||= T.let([], T.nilable(T::Array[Extension]))
+      end
+
+      # Discovers and loads all extensions. Returns the list of activated extensions
+      sig { returns(T::Array[Extension]) }
+      def load_extensions
+        # Require all extensions entry points, which should be placed under
+        # `some_gem/lib/ruby_lsp/your_gem_name/extension.rb`
+        Gem.find_files("ruby_lsp/**/extension.rb").each do |extension|
+          require File.expand_path(extension)
+        rescue => e
+          warn(e.message)
+          warn(e.backtrace.to_s) # rubocop:disable Lint/RedundantStringCoercion
+        end
+
+        # Activate each one of the discovered extensions. If any problems occur in the extensions, we don't want to
+        # fail to boot the server
+        extensions.each do |extension|
+          extension.activate
+          nil
+        rescue => e
+          extension.add_error(e)
+        end
+      end
+    end
+
+    sig { void }
+    def initialize
+      @errors = T.let([], T::Array[StandardError])
+    end
+
+    sig { params(error: StandardError).returns(T.self_type) }
+    def add_error(error)
+      @errors << error
+      self
+    end
+
+    sig { returns(T::Boolean) }
+    def error?
+      @errors.any?
+    end
+
+    sig { returns(String) }
+    def formatted_errors
+      <<~ERRORS
+        #{name}:
+          #{@errors.map(&:message).join("\n")}
+      ERRORS
+    end
+
+    sig { returns(String) }
+    def backtraces
+      @errors.filter_map(&:backtrace).join("\n\n")
+    end
+
+    # Each extension should implement `MyExtension#activate` and use to perform any sort of initialization, such as
+    # reading information into memory or even spawning a separate process
+    sig { abstract.void }
+    def activate; end
+
+    # Extensions should override the `name` method to return the extension name
+    sig { abstract.returns(String) }
+    def name; end
+  end
+end

data/lib/ruby_lsp/internal.rb

@@ -15,3 +15,4 @@ require "ruby_lsp/event_emitter"
 require "ruby_lsp/requests"
 require "ruby_lsp/listener"
 require "ruby_lsp/store"
+require "ruby_lsp/extension"

data/lib/ruby_lsp/listener.rb

@@ -20,6 +20,16 @@ module RubyLsp
       sig { returns(T.nilable(T::Array[Symbol])) }
       attr_reader :events
 
+      sig { returns(T::Array[T.class_of(Listener)]) }
+      def listeners
+        @listeners ||= T.let([], T.nilable(T::Array[T.class_of(Listener)]))
+      end
+
+      sig { params(listener: T.class_of(Listener)).void }
+      def add_listener(listener)
+        listeners << listener
+      end
+
       # All listener events must be defined inside of a `listener_events` block. This is to ensure we know which events
       # have been registered. Defining an event outside of this block will simply not register it and it'll never be
       # invoked

data/lib/ruby_lsp/requests/hover.rb

@@ -41,6 +41,21 @@ module RubyLsp
         super()
       end
 
+      # Merges responses from other hover listeners
+      sig { params(other: Listener[ResponseType]).returns(T.self_type) }
+      def merge_response!(other)
+        other_response = other.response
+        return self unless other_response
+
+        if @response.nil?
+          @response = other.response
+        else
+          @response.contents.value << other_response.contents.value << "\n\n"
+        end
+
+        self
+      end
+
       listener_events do
         sig { params(node: SyntaxTree::Command).void }
         def on_command(node)

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -80,6 +80,10 @@ module RubyLsp
 
       sig { void }
       def handle_statement_end
+        # If a keyword occurs in a line which appears be a comment or a string, we will not try to format it, since
+        # it could be a coincidental match. This approach is not perfect, but it should cover most cases.
+        return if @previous_line.start_with?(/["'#]/)
+
         return unless END_REGEXES.any? { |regex| regex.match?(@previous_line) }
 
         indents = " " * @indentation

data/lib/ruby_lsp/server.rb

@@ -23,6 +23,7 @@ module RubyLsp
       @jobs = T.let({}, T::Hash[T.any(String, Integer), Job])
       @mutex = T.let(Mutex.new, Mutex)
       @worker = T.let(new_worker, Thread)
+      @current_request_id = T.let(1, Integer)
 
       Thread.main.priority = 1
     end
@@ -54,7 +55,7 @@ module RubyLsp
           @worker.join
           @store.clear
 
-          finalize_request(Result.new(response: nil, notifications: []), request)
+          finalize_request(Result.new(response: nil, messages: []), request)
         when "exit"
           # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
           # https://microsoft.github.io/language-server-protocol/specification/#exit
@@ -88,7 +89,7 @@ module RubyLsp
 
           result = if job.cancelled
             # We need to return nil to the client even if the request was cancelled
-            Result.new(response: nil, notifications: [])
+            Result.new(response: nil, messages: [])
           else
             Executor.new(@store).execute(request)
           end
@@ -105,9 +106,6 @@ module RubyLsp
         error = result.error
         response = result.response
 
-        # If the response include any notifications, go through them and publish each one
-        result.notifications.each { |n| @writer.write(method: n.message, params: n.params) }
-
         if error
           @writer.write(
             id: request[:id],
@@ -121,6 +119,17 @@ module RubyLsp
           @writer.write(id: request[:id], result: response)
         end
 
+        # If the response include any messages, go through them and publish each one
+        result.messages.each do |n|
+          case n
+          when Notification
+            @writer.write(method: n.message, params: n.params)
+          when Request
+            @writer.write(id: @current_request_id, method: n.message, params: n.params)
+            @current_request_id += 1
+          end
+        end
+
         request_time = result.request_time
         if request_time
           @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))

data/lib/ruby_lsp/utils.rb

@@ -9,8 +9,11 @@ module RubyLsp
   WORKSPACE_URI = T.let("file://#{Dir.pwd}".freeze, String) # rubocop:disable Style/RedundantFreeze
 
   # A notification to be sent to the client
-  class Notification
+  class Message
     extend T::Sig
+    extend T::Helpers
+
+    abstract!
 
     sig { returns(String) }
     attr_reader :message
@@ -25,6 +28,9 @@ module RubyLsp
     end
   end
 
+  class Notification < Message; end
+  class Request < Message; end
+
   # The final result of running a request before its IO is finalized
   class Result
     extend T::Sig
@@ -32,8 +38,8 @@ module RubyLsp
     sig { returns(T.untyped) }
     attr_reader :response
 
-    sig { returns(T::Array[Notification]) }
-    attr_reader :notifications
+    sig { returns(T::Array[Message]) }
+    attr_reader :messages
 
     sig { returns(T.nilable(Exception)) }
     attr_reader :error
@@ -44,14 +50,14 @@ module RubyLsp
     sig do
       params(
         response: T.untyped,
-        notifications: T::Array[Notification],
+        messages: T::Array[Message],
         error: T.nilable(Exception),
         request_time: T.nilable(Float),
       ).void
     end
-    def initialize(response:, notifications:, error: nil, request_time: nil)
+    def initialize(response:, messages:, error: nil, request_time: nil)
       @response = response
-      @notifications = notifications
+      @messages = messages
       @error = error
       @request_time = request_time
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-04-11 00:00:00.000000000 Z
+date: 2023-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -75,6 +75,7 @@ files:
 - lib/ruby_lsp/document.rb
 - lib/ruby_lsp/event_emitter.rb
 - lib/ruby_lsp/executor.rb
+- lib/ruby_lsp/extension.rb
 - lib/ruby_lsp/internal.rb
 - lib/ruby_lsp/listener.rb
 - lib/ruby_lsp/requests.rb
@@ -131,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.12
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby