ruby-lsp 0.4.2 → 0.5.0

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Code action resolve demo](../../misc/code_action_resolve.gif)
+    # ![Code action resolve demo](../../code_action_resolve.gif)
     #
     # The [code action resolve](https://microsoft.github.io/language-server-protocol/specification#codeAction_resolve)
     # request is used to to resolve the edit field for a given code action, if it is not already provided in the
@@ -54,7 +54,8 @@ module RubyLsp
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest statements node, so that we place the refactor in a valid position
-        closest_statements = locate(T.must(@document.tree), start_index, node_types: [SyntaxTree::Statements]).first
+        closest_statements, parent_statements = @document
+          .locate(T.must(@document.tree), start_index, node_types: [SyntaxTree::Statements])
         return Error::InvalidTargetRange if closest_statements.nil?
 
         # Find the node with the end line closest to the requested position, so that we can place the refactor
@@ -64,25 +65,51 @@ module RubyLsp
           distance <= 0 ? Float::INFINITY : distance
         end
 
-        # When trying to extract the first node inside of a statements block, then we can just select one line above it
-        target_line = if closest_node == closest_statements.child_nodes.first
-          closest_node.location.start_line - 1
+        # Find the parent expression of the closest node
+        parent_expression = parent_statements.child_nodes.compact.find do |node|
+          loc = node.location
+          loc.start_line - 1 <= source_range.dig(:start, :line) && loc.end_line - 1 >= source_range.dig(:end, :line)
+        end if parent_statements
+
+        closest_node_loc = closest_node.location
+        # If the parent expression is a single line block, then we have to extract it inside of the oneline block
+        if parent_expression.is_a?(SyntaxTree::MethodAddBlock) &&
+            parent_expression.location.start_line == parent_expression.location.end_line
+
+          variable_source = " #{NEW_VARIABLE_NAME} = #{extracted_source};"
+          character = source_range.dig(:start, :character) - 1
+          target_range = {
+            start: { line: closest_node_loc.end_line - 1, character: character },
+            end: { line: closest_node_loc.end_line - 1, character: character },
+          }
         else
-          closest_node.location.end_line
-        end
-
-        lines = @document.source.lines
-        indentation = T.must(T.must(lines[target_line - 1])[/\A */]).size
-
-        target_range = {
-          start: { line: target_line, character: indentation },
-          end: { line: target_line, character: indentation },
-        }
-
-        variable_source = if T.must(lines[target_line]).strip.empty?
-          "\n#{" " * indentation}#{NEW_VARIABLE_NAME} = #{extracted_source}"
-        else
-          "#{NEW_VARIABLE_NAME} = #{extracted_source}\n#{" " * indentation}"
+          # If the closest node covers the requested location, then we're extracting a statement nested inside of it. In
+          # that case, we want to place the extraction at the start of the closest node (one line above). Otherwise, we
+          # want to place the extract right below the closest node
+          if closest_node_loc.start_line - 1 <= source_range.dig(
+            :start,
+            :line,
+          ) && closest_node_loc.end_line - 1 >= source_range.dig(:end, :line)
+            indentation_line = closest_node_loc.start_line - 1
+            target_line = indentation_line
+          else
+            target_line = closest_node_loc.end_line
+            indentation_line = closest_node_loc.end_line - 1
+          end
+
+          lines = @document.source.lines
+          indentation = T.must(T.must(lines[indentation_line])[/\A */]).size
+
+          target_range = {
+            start: { line: target_line, character: indentation },
+            end: { line: target_line, character: indentation },
+          }
+
+          variable_source = if T.must(lines[target_line]).strip.empty?
+            "\n#{" " * indentation}#{NEW_VARIABLE_NAME} = #{extracted_source}"
+          else
+            "#{NEW_VARIABLE_NAME} = #{extracted_source}\n#{" " * indentation}"
+          end
         end
 
         Interface::CodeAction.new(

data/lib/ruby_lsp/requests/code_actions.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Code actions demo](../../misc/code_actions.gif)
+    # ![Code actions demo](../../code_actions.gif)
     #
     # The [code actions](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeAction)
     # request informs the editor of RuboCop quick fixes that can be applied. These are accessible by hovering over a
@@ -21,16 +21,15 @@ module RubyLsp
 
       sig do
         params(
-          uri: String,
           document: Document,
           range: Document::RangeShape,
           context: T::Hash[Symbol, T.untyped],
         ).void
       end
-      def initialize(uri, document, range, context)
+      def initialize(document, range, context)
         super(document)
 
-        @uri = uri
+        @uri = T.let(document.uri, String)
         @range = range
         @context = context
       end
@@ -49,7 +48,9 @@ module RubyLsp
           code_action if diagnostic.dig(:data, :correctable) && cover?(range)
         end
 
-        code_actions << refactor_code_action(@range, @uri)
+        # Only add refactor actions if there's a non empty selection in the editor
+        code_actions << refactor_code_action(@range, @uri) unless @range.dig(:start) == @range.dig(:end)
+        code_actions
       end
 
       private

data/lib/ruby_lsp/requests/code_lens.rb

@@ -0,0 +1,151 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Code lens demo](../../code_lens.gif)
+    #
+    # This feature is currently experimental. Clients will need to pass `experimentalFeaturesEnabled`
+    # in the initialization options to enable it.
+    #
+    # The
+    # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
+    # request informs the editor of runnable commands such as tests
+    #
+    # # Example
+    #
+    # ```ruby
+    # # Run
+    # class Test < Minitest::Test
+    # end
+    # ```
+    class CodeLens < Listener
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[Interface::CodeLens] } }
+
+      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 { 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)
+
+        emitter.register(self, :on_class, :on_def, :on_command, :after_command, :on_call, :after_call, :on_vcall)
+      end
+
+      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
+      end
+
+      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(
+              node,
+              name: method_name,
+              command: BASE_COMMAND + @path + " --name " + method_name,
+            )
+          end
+        end
+      end
+
+      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 { 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
+          ident_value = T.cast(ident, SyntaxTree::Ident).value
+          if ACCESS_MODIFIERS.include?(ident_value)
+            @prev_visibility = @visibility
+            @visibility = ident_value
+          end
+        end
+      end
+
+      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)
+          @prev_visibility = vcall_value
+          @visibility = vcall_value
+        end
+      end
+
+      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:)
+        @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
+  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)
@@ -21,11 +21,11 @@ module RubyLsp
     class Diagnostics < BaseRequest
       extend T::Sig
 
-      sig { params(uri: String, document: Document).void }
-      def initialize(uri, document)
+      sig { params(document: Document).void }
+      def initialize(document)
         super(document)
 
-        @uri = uri
+        @uri = T.let(document.uri, String)
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Support::RuboCopDiagnostic], Object))) }
@@ -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
@@ -29,14 +29,13 @@ module RubyLsp
       def initialize(document, position)
         super(document)
 
-        @highlights = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
+        @highlights = T.let([], T::Array[Interface::DocumentHighlight])
         return unless document.parsed?
 
-        position = document.create_scanner.find_char_position(position)
-        @target = T.let(find(T.must(document.tree), position), T.nilable(Support::HighlightTarget))
+        @target = T.let(find(position), T.nilable(Support::HighlightTarget))
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::DocumentHighlight], Object)) }
       def run
         # no @target means the target is not highlightable
         visit(@document.tree) if @document.parsed? && @target
@@ -68,12 +67,11 @@ module RubyLsp
 
       sig do
         params(
-          node: SyntaxTree::Node,
-          position: Integer,
+          position: Document::PositionShape,
         ).returns(T.nilable(Support::HighlightTarget))
       end
-      def find(node, position)
-        matched, parent = locate(node, position)
+      def find(position)
+        matched, parent = @document.locate_node(position)
 
         return unless matched && parent
         return unless matched.is_a?(SyntaxTree::Ident) || DIRECT_HIGHLIGHTS.include?(matched.class)
@@ -90,7 +88,7 @@ module RubyLsp
       sig { params(match: Support::HighlightTarget::HighlightMatch).void }
       def add_highlight(match)
         range = range_from_syntax_tree_node(match.node)
-        @highlights << LanguageServer::Protocol::Interface::DocumentHighlight.new(range: range, kind: match.type)
+        @highlights << Interface::DocumentHighlight.new(range: range, kind: match.type)
       end
     end
   end

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,34 +72,33 @@ module RubyLsp
         end
       end
 
-      sig { params(uri: String, document: Document).void }
-      def initialize(uri, 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(uri)
         @gem_version = T.let(version_match && version_match[0], T.nilable(String))
-        @links = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentLink])
-      end
+        @response = T.let([], T::Array[Interface::DocumentLink])
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::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
 
-        uri = T.cast(URI(match[0]), URI::Source)
+        uri = T.cast(URI(T.must(match[0])), URI::Source)
         gem_version = T.must(resolve_version(uri))
         file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, uri.path)
         return if file_path.nil?
 
-        @links << LanguageServer::Protocol::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(
         {
@@ -66,49 +69,62 @@ module RubyLsp
       class SymbolHierarchyRoot
         extend T::Sig
 
-        sig { returns(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol]) }
+        sig { returns(T::Array[Interface::DocumentSymbol]) }
         attr_reader :children
 
         sig { void }
         def initialize
-          @children = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentSymbol])
+          @children = T.let([], T::Array[Interface::DocumentSymbol])
         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, LanguageServer::Protocol::Interface::DocumentSymbol)],
+          T::Array[T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)],
         )
-      end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::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,9 +148,11 @@ module RubyLsp
         )
       end
 
-      sig { override.params(node: SyntaxTree::DefNode).void }
-      def visit_def(node)
-        if node.target&.value&.value == "self"
+      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"
           name = "self.#{node.name.value}"
           kind = :method
         else
@@ -150,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,
@@ -178,9 +200,10 @@ module RubyLsp
         )
       end
 
-      sig { override.params(node: SyntaxTree::VarField).void }
-      def visit_var_field(node)
-        kind = case node.value
+      sig { params(node: SyntaxTree::VarField).void }
+      def on_var_field(node)
+        value = node.value
+        kind = case value
         when SyntaxTree::Const
           :constant
         when SyntaxTree::CVar, SyntaxTree::IVar
@@ -190,10 +213,10 @@ module RubyLsp
         end
 
         create_document_symbol(
-          name: node.value.value,
+          name: value.value,
           kind: kind,
           range_node: node,
-          selection_range_node: node.value,
+          selection_range_node: value,
         )
       end
 
@@ -205,10 +228,10 @@ module RubyLsp
           kind: Symbol,
           range_node: SyntaxTree::Node,
           selection_range_node: SyntaxTree::Node,
-        ).returns(LanguageServer::Protocol::Interface::DocumentSymbol)
+        ).returns(Interface::DocumentSymbol)
       end
       def create_document_symbol(name:, kind:, range_node:, selection_range_node:)
-        symbol = LanguageServer::Protocol::Interface::DocumentSymbol.new(
+        symbol = Interface::DocumentSymbol.new(
           name: name,
           kind: SYMBOL_KIND[kind],
           range: range_from_syntax_tree_node(range_node),