ruby-lsp 0.4.5 → 0.5.0

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,10 +35,12 @@ 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
 
       # Merges responses from other hover listeners
@@ -56,25 +58,23 @@ module RubyLsp
         self
       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
+      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::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)
+      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
+        @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.

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"