ruby-lsp 0.4.4 → 0.5.0

data/lib/ruby_lsp/requests/code_lens.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Code lens demo](../../misc/code_lens.gif)
+    # ![Code lens demo](../../code_lens.gif)
     #
     # This feature is currently experimental. Clients will need to pass `experimentalFeaturesEnabled`
     # in the initialization options to enable it.
@@ -19,41 +19,41 @@ module RubyLsp
     # class Test < Minitest::Test
     # end
     # ```
+    class CodeLens < Listener
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[Interface::CodeLens] } }
 
-    class CodeLens < BaseRequest
       BASE_COMMAND = T.let((File.exist?("Gemfile.lock") ? "bundle exec ruby" : "ruby") + " -Itest ", String)
       ACCESS_MODIFIERS = T.let(["public", "private", "protected"], T::Array[String])
 
-      sig do
-        params(
-          document: Document,
-        ).void
-      end
-      def initialize(document)
-        super(document)
-        @results = T.let([], T::Array[Interface::CodeLens])
-        @path = T.let(document.uri.delete_prefix("file://"), String)
-        @modifier = T.let("public", String)
-      end
+      sig { override.returns(ResponseType) }
+      attr_reader :response
+
+      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(uri, emitter, message_queue)
+        super(emitter, message_queue)
+
+        @response = T.let([], ResponseType)
+        @path = T.let(T.must(URI(uri).path), String)
+        @visibility = T.let("public", String)
+        @prev_visibility = T.let("public", String)
 
-      sig { override.returns(T.all(T::Array[Interface::CodeLens], Object)) }
-      def run
-        visit(@document.tree) if @document.parsed?
-        @results
+        emitter.register(self, :on_class, :on_def, :on_command, :after_command, :on_call, :after_call, :on_vcall)
       end
 
-      sig { override.params(node: SyntaxTree::ClassDeclaration).void }
-      def visit_class(node)
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      def on_class(node)
         class_name = node.constant.constant.value
         if class_name.end_with?("Test")
           add_code_lens(node, name: class_name, command: BASE_COMMAND + @path)
         end
-        visit(node.bodystmt)
       end
 
-      sig { override.params(node: SyntaxTree::DefNode).void }
-      def visit_def(node)
-        if @modifier == "public"
+      sig { params(node: SyntaxTree::DefNode).void }
+      def on_def(node)
+        if @visibility == "public"
           method_name = node.name.value
           if method_name.start_with?("test_")
             add_code_lens(
@@ -65,69 +65,85 @@ module RubyLsp
         end
       end
 
-      sig { override.params(node: SyntaxTree::Command).void }
-      def visit_command(node)
-        if node.message.value == "public"
-          with_visiblity("public", node)
+      sig { params(node: SyntaxTree::Command).void }
+      def on_command(node)
+        if ACCESS_MODIFIERS.include?(node.message.value) && node.arguments.parts.any?
+          @prev_visibility = @visibility
+          @visibility = node.message.value
         end
       end
 
-      sig { override.params(node: SyntaxTree::CallNode).void }
-      def visit_call(node)
+      sig { params(node: SyntaxTree::Command).void }
+      def after_command(node)
+        @visibility = @prev_visibility
+      end
+
+      sig { params(node: SyntaxTree::CallNode).void }
+      def on_call(node)
         ident = node.message if node.message.is_a?(SyntaxTree::Ident)
 
         if ident
-          if T.cast(ident, SyntaxTree::Ident).value == "public"
-            with_visiblity("public", node)
+          ident_value = T.cast(ident, SyntaxTree::Ident).value
+          if ACCESS_MODIFIERS.include?(ident_value)
+            @prev_visibility = @visibility
+            @visibility = ident_value
           end
         end
       end
 
-      sig { override.params(node: SyntaxTree::VCall).void }
-      def visit_vcall(node)
+      sig { params(node: SyntaxTree::CallNode).void }
+      def after_call(node)
+        @visibility = @prev_visibility
+      end
+
+      sig { params(node: SyntaxTree::VCall).void }
+      def on_vcall(node)
         vcall_value = node.value.value
 
         if ACCESS_MODIFIERS.include?(vcall_value)
-          @modifier = vcall_value
+          @prev_visibility = vcall_value
+          @visibility = vcall_value
         end
       end
 
-      private
-
-      sig do
-        params(
-          visibility: String,
-          node: T.any(SyntaxTree::CallNode, SyntaxTree::Command),
-        ).void
-      end
-      def with_visiblity(visibility, node)
-        current_visibility = @modifier
-        @modifier = visibility
-        visit(node.arguments)
-      ensure
-        @modifier = T.must(current_visibility)
+      sig { params(other: Listener[ResponseType]).returns(T.self_type) }
+      def merge_response!(other)
+        @response.concat(other.response)
+        self
       end
 
+      private
+
       sig { params(node: SyntaxTree::Node, name: String, command: String).void }
       def add_code_lens(node, name:, command:)
-        @results << Interface::CodeLens.new(
-          range: range_from_syntax_tree_node(node),
-          command: Interface::Command.new(
-            title: "Run",
-            command: "rubyLsp.runTest",
-            arguments: [
-              @path,
-              name,
-              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,
-              },
-            ],
-          ),
-          data: { type: "test" },
+        @response << create_code_lens(
+          node,
+          title: "Run",
+          command_name: "rubyLsp.runTest",
+          path: @path,
+          name: name,
+          test_command: command,
+          type: "test",
+        )
+
+        @response << create_code_lens(
+          node,
+          title: "Run In Terminal",
+          command_name: "rubyLsp.runTestInTerminal",
+          path: @path,
+          name: name,
+          test_command: command,
+          type: "test_in_terminal",
+        )
+
+        @response << create_code_lens(
+          node,
+          title: "Debug",
+          command_name: "rubyLsp.debugTest",
+          path: @path,
+          name: name,
+          test_command: command,
+          type: "debug",
         )
       end
     end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -5,7 +5,7 @@ require "ruby_lsp/requests/support/rubocop_diagnostics_runner"
 
 module RubyLsp
   module Requests
-    # ![Diagnostics demo](../../misc/diagnostics.gif)
+    # ![Diagnostics demo](../../diagnostics.gif)
     #
     # The
     # [diagnostics](https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics)
@@ -34,7 +34,7 @@ module RubyLsp
         return unless defined?(Support::RuboCopDiagnosticsRunner)
 
         # Don't try to run RuboCop diagnostics for files outside the current working directory
-        return unless @uri.start_with?(WORKSPACE_URI)
+        return unless URI(@uri).path&.start_with?(T.must(WORKSPACE_URI.path))
 
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Document highlight demo](../../misc/document_highlight.gif)
+    # ![Document highlight demo](../../document_highlight.gif)
     #
     # The [document highlight](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentHighlight)
     # informs the editor all relevant elements of the currently pointed item for highlighting. For example, when

data/lib/ruby_lsp/requests/document_link.rb

@@ -5,7 +5,7 @@ require "ruby_lsp/requests/support/source_uri"
 
 module RubyLsp
   module Requests
-    # ![Document link demo](../../misc/document_link.gif)
+    # ![Document link demo](../../document_link.gif)
     #
     # The [document link](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentLink)
     # makes `# source://PATH_TO_FILE#line` comments in a Ruby/RBI file clickable if the file exists.
@@ -18,8 +18,11 @@ module RubyLsp
     # def format(source, maxwidth = T.unsafe(nil))
     # end
     # ```
-    class DocumentLink < BaseRequest
+    class DocumentLink < Listener
       extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[Interface::DocumentLink] } }
 
       GEM_TO_VERSION_MAP = T.let(
         [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].map! do |s|
@@ -69,25 +72,24 @@ module RubyLsp
         end
       end
 
-      sig { params(document: Document).void }
-      def initialize(document)
-        super(document)
+      sig { override.returns(ResponseType) }
+      attr_reader :response
+
+      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(uri, emitter, message_queue)
+        super(emitter, message_queue)
 
         # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
         # in the URI
-        version_match = /(?<=%40)[\d.]+(?=\.rbi$)/.match(document.uri)
+        version_match = /(?<=%40)[\d.]+(?=\.rbi$)/.match(uri)
         @gem_version = T.let(version_match && version_match[0], T.nilable(String))
-        @links = T.let([], T::Array[Interface::DocumentLink])
-      end
+        @response = T.let([], T::Array[Interface::DocumentLink])
 
-      sig { override.returns(T.all(T::Array[Interface::DocumentLink], Object)) }
-      def run
-        visit(@document.tree) if @document.parsed?
-        @links
+        emitter.register(self, :on_comment)
       end
 
-      sig { override.params(node: SyntaxTree::Comment).void }
-      def visit_comment(node)
+      sig { params(node: SyntaxTree::Comment).void }
+      def on_comment(node)
         match = node.value.match(%r{source://.*#\d+$})
         return unless match
 
@@ -96,7 +98,7 @@ module RubyLsp
         file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, uri.path)
         return if file_path.nil?
 
-        @links << Interface::DocumentLink.new(
+        @response << Interface::DocumentLink.new(
           range: range_from_syntax_tree_node(node),
           target: "file://#{file_path}##{uri.line_number}",
           tooltip: "Jump to #{file_path}##{uri.line_number}",

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Document symbol demo](../../misc/document_symbol.gif)
+    # ![Document symbol demo](../../document_symbol.gif)
     #
     # The [document
     # symbol](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentSymbol) request
@@ -26,8 +26,11 @@ module RubyLsp
     #   end
     # end
     # ```
-    class DocumentSymbol < BaseRequest
+    class DocumentSymbol < Listener
       extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[Interface::DocumentSymbol] } }
 
       SYMBOL_KIND = T.let(
         {
@@ -75,40 +78,53 @@ module RubyLsp
         end
       end
 
-      sig { params(document: Document).void }
-      def initialize(document)
+      sig { override.returns(T::Array[Interface::DocumentSymbol]) }
+      attr_reader :response
+
+      sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(emitter, message_queue)
         super
 
         @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
+        @response = T.let(@root.children, T::Array[Interface::DocumentSymbol])
         @stack = T.let(
           [@root],
           T::Array[T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)],
         )
-      end
 
-      sig { override.returns(T.all(T::Array[Interface::DocumentSymbol], Object)) }
-      def run
-        visit(@document.tree) if @document.parsed?
-        @root.children
+        emitter.register(
+          self,
+          :on_class,
+          :after_class,
+          :on_command,
+          :on_const_path_field,
+          :on_def,
+          :after_def,
+          :on_module,
+          :after_module,
+          :on_top_const_field,
+          :on_var_field,
+        )
       end
 
-      sig { override.params(node: SyntaxTree::ClassDeclaration).void }
-      def visit_class(node)
-        symbol = create_document_symbol(
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      def on_class(node)
+        @stack << create_document_symbol(
           name: full_constant_name(node.constant),
           kind: :class,
           range_node: node,
           selection_range_node: node.constant,
         )
+      end
 
-        @stack << symbol
-        visit(node.bodystmt)
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      def after_class(node)
         @stack.pop
       end
 
-      sig { override.params(node: SyntaxTree::Command).void }
-      def visit_command(node)
-        return visit(node.arguments) unless ATTR_ACCESSORS.include?(node.message.value)
+      sig { params(node: SyntaxTree::Command).void }
+      def on_command(node)
+        return unless ATTR_ACCESSORS.include?(node.message.value)
 
         node.arguments.parts.each do |argument|
           next unless argument.is_a?(SyntaxTree::SymbolLiteral)
@@ -122,8 +138,8 @@ module RubyLsp
         end
       end
 
-      sig { override.params(node: SyntaxTree::ConstPathField).void }
-      def visit_const_path_field(node)
+      sig { params(node: SyntaxTree::ConstPathField).void }
+      def on_const_path_field(node)
         create_document_symbol(
           name: node.constant.value,
           kind: :constant,
@@ -132,8 +148,8 @@ module RubyLsp
         )
       end
 
-      sig { override.params(node: SyntaxTree::DefNode).void }
-      def visit_def(node)
+      sig { params(node: SyntaxTree::DefNode).void }
+      def on_def(node)
         target = node.target
 
         if target.is_a?(SyntaxTree::VarRef) && target.value.is_a?(SyntaxTree::Kw) && target.value.value == "self"
@@ -152,26 +168,30 @@ module RubyLsp
         )
 
         @stack << symbol
-        visit(node.bodystmt)
+      end
+
+      sig { params(node: SyntaxTree::DefNode).void }
+      def after_def(node)
         @stack.pop
       end
 
-      sig { override.params(node: SyntaxTree::ModuleDeclaration).void }
-      def visit_module(node)
-        symbol = create_document_symbol(
+      sig { params(node: SyntaxTree::ModuleDeclaration).void }
+      def on_module(node)
+        @stack << create_document_symbol(
           name: full_constant_name(node.constant),
           kind: :module,
           range_node: node,
           selection_range_node: node.constant,
         )
+      end
 
-        @stack << symbol
-        visit(node.bodystmt)
+      sig { params(node: SyntaxTree::ModuleDeclaration).void }
+      def after_module(node)
         @stack.pop
       end
 
-      sig { override.params(node: SyntaxTree::TopConstField).void }
-      def visit_top_const_field(node)
+      sig { params(node: SyntaxTree::TopConstField).void }
+      def on_top_const_field(node)
         create_document_symbol(
           name: node.constant.value,
           kind: :constant,
@@ -180,8 +200,8 @@ module RubyLsp
         )
       end
 
-      sig { override.params(node: SyntaxTree::VarField).void }
-      def visit_var_field(node)
+      sig { params(node: SyntaxTree::VarField).void }
+      def on_var_field(node)
         value = node.value
         kind = case value
         when SyntaxTree::Const

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Folding ranges demo](../../misc/folding_ranges.gif)
+    # ![Folding ranges demo](../../folding_ranges.gif)
     #
     # The [folding ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_foldingRange)
     # request informs the editor of the ranges where and how code can be folded.

data/lib/ruby_lsp/requests/formatting.rb

@@ -6,13 +6,17 @@ require "ruby_lsp/requests/support/syntax_tree_formatting_runner"
 
 module RubyLsp
   module Requests
-    # ![Formatting symbol demo](../../misc/formatting.gif)
+    # ![Formatting symbol demo](../../formatting.gif)
     #
     # The [formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_formatting)
     # request uses RuboCop to fix auto-correctable offenses in the document. This requires enabling format on save and
     # registering the ruby-lsp as the Ruby formatter.
     #
-    # If RuboCop is not available, the request will fall back to SyntaxTree.
+    # The `rubyLsp.formatter` setting specifies which formatter to use.
+    # If set to `auto`` then it behaves as follows:
+    # * It will use RuboCop if it is part of the bundle.
+    # * If RuboCop is not available, and `syntax_tree` is a direct dependency, it will use that.
+    # * Otherwise, no formatting will be applied.
     #
     # # Example
     #
@@ -32,14 +36,7 @@ module RubyLsp
         super(document)
 
         @uri = T.let(document.uri, String)
-        @formatter = T.let(
-          if formatter == "auto"
-            defined?(Support::RuboCopFormattingRunner) ? "rubocop" : "syntax_tree"
-          else
-            formatter
-          end,
-          String,
-        )
+        @formatter = formatter
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
@@ -72,7 +69,9 @@ module RubyLsp
       def formatted_file
         case @formatter
         when "rubocop"
-          Support::RuboCopFormattingRunner.instance.run(@uri, @document)
+          if defined?(Support::RuboCopFormattingRunner)
+            Support::RuboCopFormattingRunner.instance.run(@uri, @document)
+          end
         when "syntax_tree"
           Support::SyntaxTreeFormattingRunner.instance.run(@uri, @document)
         else

data/lib/ruby_lsp/requests/hover.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Hover demo](../../misc/rails_document_link_hover.gif)
+    # ![Hover demo](../../rails_document_link_hover.gif)
     #
     # The [hover request](https://microsoft.github.io/language-server-protocol/specification#textDocument_hover)
     # renders a clickable link to the code's official documentation.
@@ -35,31 +35,46 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { void }
-      def initialize
+      sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(emitter, message_queue)
+        super
+
         @response = T.let(nil, ResponseType)
-        super()
+        emitter.register(self, :on_command, :on_const_path_ref, :on_call)
       end
 
-      listener_events do
-        sig { params(node: SyntaxTree::Command).void }
-        def on_command(node)
-          message = node.message
-          @response = generate_rails_document_link_hover(message.value, message)
-        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
 
-        sig { params(node: SyntaxTree::ConstPathRef).void }
-        def on_const_path_ref(node)
-          @response = generate_rails_document_link_hover(full_constant_name(node), node)
+        if @response.nil?
+          @response = other.response
+        else
+          @response.contents.value << other_response.contents.value << "\n\n"
         end
 
-        sig { params(node: SyntaxTree::CallNode).void }
-        def on_call(node)
-          message = node.message
-          return if message.is_a?(Symbol)
+        self
+      end
 
-          @response = generate_rails_document_link_hover(message.value, message)
-        end
+      sig { params(node: SyntaxTree::Command).void }
+      def on_command(node)
+        message = node.message
+        @response = generate_rails_document_link_hover(message.value, message)
+      end
+
+      sig { params(node: SyntaxTree::ConstPathRef).void }
+      def on_const_path_ref(node)
+        @response = generate_rails_document_link_hover(full_constant_name(node), node)
+      end
+
+      sig { params(node: SyntaxTree::CallNode).void }
+      def on_call(node)
+        message = node.message
+        return if message.is_a?(Symbol)
+
+        @response = generate_rails_document_link_hover(message.value, message)
       end
 
       private

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Inlay hint demo](../../misc/inlay_hint.gif)
+    # ![Inlay hint demo](../../inlay_hint.gif)
     #
     # [Inlay hints](https://microsoft.github.io/language-server-protocol/specification#textDocument_inlayHint)
     # are labels added directly in the code that explicitly show the user something that might

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![On type formatting demo](../../misc/on_type_formatting.gif)
+    # ![On type formatting demo](../../on_type_formatting.gif)
     #
     # The [on type formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_onTypeFormatting)
     # request formats code as the user is typing. For example, automatically adding `end` to class definitions.
@@ -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