ruby-lsp 0.4.4 → 0.5.0

data/lib/ruby_lsp/requests/path_completion.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Path completion demo](../../misc/path_completion.gif)
+    # ![Path completion demo](../../path_completion.gif)
     #
     # The [completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
     # request looks up Ruby files in the $LOAD_PATH to suggest path completion inside `require` statements.
@@ -13,29 +13,28 @@ module RubyLsp
     # ```ruby
     # require "ruby_lsp/requests" # --> completion: suggests `base_request`, `code_actions`, ...
     # ```
-    class PathCompletion < BaseRequest
+    class PathCompletion < Listener
       extend T::Sig
+      extend T::Generic
 
-      sig { params(document: Document, position: Document::PositionShape).void }
-      def initialize(document, position)
-        super(document)
+      ResponseType = type_member { { fixed: T::Array[Interface::CompletionItem] } }
 
-        @tree = T.let(Support::PrefixTree.new(collect_load_path_files), Support::PrefixTree)
-        @position = position
-      end
+      sig { override.returns(ResponseType) }
+      attr_reader :response
 
-      sig { override.returns(T.all(T::Array[Interface::CompletionItem], Object)) }
-      def run
-        # We can't verify if we're inside a require when there are syntax errors
-        return [] if @document.syntax_error?
+      sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(emitter, message_queue)
+        super
+        @response = T.let([], ResponseType)
+        @tree = T.let(Support::PrefixTree.new(collect_load_path_files), Support::PrefixTree)
 
-        target = T.let(find, T.nilable(SyntaxTree::TStringContent))
-        # no target means the we are not inside a `require` call
-        return [] unless target
+        emitter.register(self, :on_tstring_content)
+      end
 
-        text = target.value
-        @tree.search(text).sort.map! do |path|
-          build_completion(path, path.delete_prefix(text))
+      sig { params(node: SyntaxTree::TStringContent).void }
+      def on_tstring_content(node)
+        @tree.search(node.value).sort.each do |path|
+          @response << build_completion(path, node)
         end
       end
 
@@ -50,48 +49,13 @@ module RubyLsp
         end
       end
 
-      sig { returns(T.nilable(SyntaxTree::TStringContent)) }
-      def find
-        char_position = @document.create_scanner.find_char_position(@position)
-        matched, parent = @document.locate(
-          T.must(@document.tree),
-          char_position,
-          node_types: [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode],
-        )
-
-        return unless matched && parent
-
-        case matched
-        when SyntaxTree::Command, SyntaxTree::CallNode, SyntaxTree::CommandCall
-          message = matched.message
-          return if message.is_a?(Symbol)
-          return unless message.value == "require"
-
-          args = matched.arguments
-          args = args.arguments if args.is_a?(SyntaxTree::ArgParen)
-          return if args.nil? || args.is_a?(SyntaxTree::ArgsForward)
-
-          argument = args.parts.first
-          return unless argument.is_a?(SyntaxTree::StringLiteral)
-
-          path_node = argument.parts.first
-          return unless path_node.is_a?(SyntaxTree::TStringContent)
-          return unless (path_node.location.start_char..path_node.location.end_char).cover?(char_position)
-
-          path_node
-        end
-      end
-
-      sig { params(label: String, insert_text: String).returns(Interface::CompletionItem) }
-      def build_completion(label, insert_text)
+      sig { params(label: String, node: SyntaxTree::TStringContent).returns(Interface::CompletionItem) }
+      def build_completion(label, node)
         Interface::CompletionItem.new(
           label: label,
           text_edit: Interface::TextEdit.new(
-            range: Interface::Range.new(
-              start: @position,
-              end: @position,
-            ),
-            new_text: insert_text,
+            range: range_from_syntax_tree_node(node),
+            new_text: label,
           ),
           kind: Constant::CompletionItemKind::REFERENCE,
         )

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Selection ranges demo](../../misc/selection_ranges.gif)
+    # ![Selection ranges demo](../../selection_ranges.gif)
     #
     # The [selection ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange)
     # request informs the editor of ranges that the user may want to select based on the location(s)

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Semantic highlighting demo](../../misc/semantic_highlighting.gif)
+    # ![Semantic highlighting demo](../../semantic_highlighting.gif)
     #
     # The [semantic
     # highlighting](https://microsoft.github.io/language-server-protocol/specification#textDocument_semanticTokens)

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

@@ -49,6 +49,42 @@ module RubyLsp
           loc = node.location
           range.cover?(loc.start_line - 1) && range.cover?(loc.end_line - 1)
         end
+
+        sig do
+          params(
+            node: SyntaxTree::Node,
+            title: String,
+            command_name: String,
+            path: String,
+            name: String,
+            test_command: String,
+            type: String,
+          ).returns(Interface::CodeLens)
+        end
+        def create_code_lens(node, title:, command_name:, path:, name:, test_command:, type:)
+          range = range_from_syntax_tree_node(node)
+          arguments = [
+            path,
+            name,
+            test_command,
+            {
+              start_line: node.location.start_line - 1,
+              start_column: node.location.start_column,
+              end_line: node.location.end_line - 1,
+              end_column: node.location.end_column,
+            },
+          ]
+
+          Interface::CodeLens.new(
+            range: range,
+            command: Interface::Command.new(
+              title: title,
+              command: command_name,
+              arguments: arguments,
+            ),
+            data: { type: type },
+          )
+        end
       end
     end
   end

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

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "ruby_lsp/requests/support/rubocop_runner"
 return unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
 
 require "cgi"

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

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "ruby_lsp/requests/support/rubocop_runner"
 return unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
 
 require "cgi"

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

@@ -25,8 +25,11 @@ module RubyLsp
             )
         end
 
-        sig { params(_uri: String, document: Document).returns(T.nilable(String)) }
-        def run(_uri, document)
+        sig { params(uri: String, document: Document).returns(T.nilable(String)) }
+        def run(uri, document)
+          relative_path = Pathname.new(URI(uri).path).relative_path_from(T.must(WORKSPACE_URI.path))
+          return if @options.ignore_files.any? { |pattern| File.fnmatch(pattern, relative_path) }
+
           SyntaxTree.format(
             document.source,
             @options.print_width,

data/lib/ruby_lsp/requests.rb

@@ -4,21 +4,21 @@
 module RubyLsp
   # Supported features
   #
-  # - {RubyLsp::Requests::DocumentSymbol}
-  # - {RubyLsp::Requests::DocumentLink}
-  # - {RubyLsp::Requests::Hover}
-  # - {RubyLsp::Requests::FoldingRanges}
-  # - {RubyLsp::Requests::SelectionRanges}
-  # - {RubyLsp::Requests::SemanticHighlighting}
-  # - {RubyLsp::Requests::Formatting}
-  # - {RubyLsp::Requests::OnTypeFormatting}
-  # - {RubyLsp::Requests::Diagnostics}
-  # - {RubyLsp::Requests::CodeActions}
-  # - {RubyLsp::Requests::CodeActionResolve}
-  # - {RubyLsp::Requests::DocumentHighlight}
-  # - {RubyLsp::Requests::InlayHints}
-  # - {RubyLsp::Requests::PathCompletion}
-  # - {RubyLsp::Requests::CodeLens}
+  # - [DocumentSymbol](rdoc-ref:RubyLsp::Requests::DocumentSymbol)
+  # - [DocumentLink](rdoc-ref:RubyLsp::Requests::DocumentLink)
+  # - [Hover](rdoc-ref:RubyLsp::Requests::Hover)
+  # - [FoldingRange](rdoc-ref:RubyLsp::Requests::FoldingRanges)
+  # - [SelectionRange](rdoc-ref:RubyLsp::Requests::SelectionRanges)
+  # - [SemanticHighlighting](rdoc-ref:RubyLsp::Requests::SemanticHighlighting)
+  # - [Formatting](rdoc-ref:RubyLsp::Requests::Formatting)
+  # - [OnTypeFormatting](rdoc-ref:RubyLsp::Requests::OnTypeFormatting)
+  # - [Diagnostic](rdoc-ref:RubyLsp::Requests::Diagnostics)
+  # - [CodeAction](rdoc-ref:RubyLsp::Requests::CodeActions)
+  # - [CodeActionResolve](rdoc-ref:RubyLsp::Requests::CodeActionResolve)
+  # - [DocumentHighlight](rdoc-ref:RubyLsp::Requests::DocumentHighlight)
+  # - [InlayHint](rdoc-ref:RubyLsp::Requests::InlayHints)
+  # - [PathCompletion](rdoc-ref:RubyLsp::Requests::PathCompletion)
+  # - [CodeLens](rdoc-ref:RubyLsp::Requests::CodeLens)
 
   module Requests
     autoload :BaseRequest, "ruby_lsp/requests/base_request"

data/lib/ruby_lsp/server.rb

@@ -24,6 +24,32 @@ module RubyLsp
       @mutex = T.let(Mutex.new, Mutex)
       @worker = T.let(new_worker, Thread)
 
+      # The messages queue includes requests and notifications to be sent to the client
+      @message_queue = T.let(Thread::Queue.new, Thread::Queue)
+
+      # Create a thread to watch the messages queue and send them to the client
+      @message_dispatcher = T.let(
+        Thread.new do
+          current_request_id = 1
+
+          loop do
+            message = @message_queue.pop
+            break if message.nil?
+
+            @mutex.synchronize do
+              case message
+              when Notification
+                @writer.write(method: message.message, params: message.params)
+              when Request
+                @writer.write(id: current_request_id, method: message.message, params: message.params)
+                current_request_id += 1
+              end
+            end
+          end
+        end,
+        Thread,
+      )
+
       Thread.main.priority = 1
     end
 
@@ -35,9 +61,8 @@ module RubyLsp
       # fall under the else branch which just pushes requests to the queue
       @reader.read do |request|
         case request[:method]
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
-              "textDocument/formatting", "textDocument/onTypeFormatting", "codeAction/resolve"
-          result = Executor.new(@store).execute(request)
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+          result = Executor.new(@store, @message_queue).execute(request)
           finalize_request(result, request)
         when "$/cancelRequest"
           # Cancel the job if it's still in the queue
@@ -45,6 +70,7 @@ module RubyLsp
         when "shutdown"
           warn("Shutting down Ruby LSP...")
 
+          @message_queue.close
           # Close the queue so that we can no longer receive items
           @job_queue.close
           # Clear any remaining jobs so that the thread can terminate
@@ -52,9 +78,10 @@ module RubyLsp
           @jobs.clear
           # Wait until the thread is finished
           @worker.join
+          @message_dispatcher.join
           @store.clear
 
-          finalize_request(Result.new(response: nil, notifications: []), request)
+          finalize_request(Result.new(response: nil), 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
@@ -65,8 +92,17 @@ module RubyLsp
           # Default case: push the request to the queue to be executed by the worker
           job = Job.new(request: request, cancelled: false)
 
-          # Remember a handle to the job, so that we can cancel it
-          @mutex.synchronize { @jobs[request[:id]] = job }
+          @mutex.synchronize do
+            # Remember a handle to the job, so that we can cancel it
+            @jobs[request[:id]] = job
+
+            # We must parse the document under a mutex lock or else we might switch threads and accept text edits in the
+            # source. Altering the source reference during parsing will put the parser in an invalid internal state,
+            # since it started parsing with one source but then it changed in the middle
+            uri = request.dig(:params, :textDocument, :uri)
+            @store.get(uri).parse if uri
+          end
+
           @job_queue << job
         end
       end
@@ -88,9 +124,9 @@ 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)
           else
-            Executor.new(@store).execute(request)
+            Executor.new(@store, @message_queue).execute(request)
           end
 
           finalize_request(result, request)
@@ -105,9 +141,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],

data/lib/ruby_lsp/store.rb

@@ -61,7 +61,7 @@ module RubyLsp
       type_parameters(:T)
         .params(
           uri: String,
-          request_name: Symbol,
+          request_name: String,
           block: T.proc.params(document: Document).returns(T.type_parameter(:T)),
         ).returns(T.type_parameter(:T))
     end

data/lib/ruby_lsp/utils.rb

@@ -6,11 +6,14 @@ module RubyLsp
   VOID = T.let(Object.new.freeze, Object)
 
   # This freeze is not redundant since the interpolated string is mutable
-  WORKSPACE_URI = T.let("file://#{Dir.pwd}".freeze, String) # rubocop:disable Style/RedundantFreeze
+  WORKSPACE_URI = T.let(URI("file://#{Dir.pwd}".freeze), URI::Generic) # 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,9 +38,6 @@ module RubyLsp
     sig { returns(T.untyped) }
     attr_reader :response
 
-    sig { returns(T::Array[Notification]) }
-    attr_reader :notifications
-
     sig { returns(T.nilable(Exception)) }
     attr_reader :error
 
@@ -44,14 +47,12 @@ module RubyLsp
     sig do
       params(
         response: T.untyped,
-        notifications: T::Array[Notification],
         error: T.nilable(Exception),
         request_time: T.nilable(Float),
       ).void
     end
-    def initialize(response:, notifications:, error: nil, request_time: nil)
+    def initialize(response:, error: nil, request_time: nil)
       @response = response
-      @notifications = notifications
       @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.5.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-04-11 00:00:00.000000000 Z
+date: 2023-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -72,9 +72,11 @@ files:
 - exe/ruby-lsp
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/ruby-lsp.rb
+- lib/ruby_lsp/check_docs.rb
 - 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 +133,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