ruby-lsp 0.4.2 → 0.4.4

data/lib/ruby_lsp/requests/base_request.rb

@@ -7,6 +7,7 @@ module RubyLsp
     class BaseRequest < SyntaxTree::Visitor
       extend T::Sig
       extend T::Helpers
+      include Support::Common
 
       abstract!
 
@@ -31,94 +32,10 @@ module RubyLsp
       # Syntax Tree implements `visit_all` using `map` instead of `each` for users who want to use the pattern
       # `result = visitor.visit(tree)`. However, we don't use that pattern and should avoid producing a new array for
       # every single node visited
-      sig { params(nodes: T::Array[SyntaxTree::Node]).void }
+      sig { params(nodes: T::Array[T.nilable(SyntaxTree::Node)]).void }
       def visit_all(nodes)
         nodes.each { |node| visit(node) }
       end
-
-      sig { params(node: SyntaxTree::Node).returns(LanguageServer::Protocol::Interface::Range) }
-      def range_from_syntax_tree_node(node)
-        loc = node.location
-
-        LanguageServer::Protocol::Interface::Range.new(
-          start: LanguageServer::Protocol::Interface::Position.new(
-            line: loc.start_line - 1,
-            character: loc.start_column,
-          ),
-          end: LanguageServer::Protocol::Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
-        )
-      end
-
-      sig do
-        params(node: T.any(SyntaxTree::ConstPathRef, SyntaxTree::ConstRef, SyntaxTree::TopConstRef)).returns(String)
-      end
-      def full_constant_name(node)
-        name = +node.constant.value
-        constant = T.let(node, SyntaxTree::Node)
-
-        while constant.is_a?(SyntaxTree::ConstPathRef)
-          constant = constant.parent
-
-          case constant
-          when SyntaxTree::ConstPathRef
-            name.prepend("#{constant.constant.value}::")
-          when SyntaxTree::VarRef
-            name.prepend("#{constant.value.value}::")
-          end
-        end
-
-        name
-      end
-
-      sig do
-        params(
-          node: SyntaxTree::Node,
-          position: Integer,
-          node_types: T::Array[T.class_of(SyntaxTree::Node)],
-        ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
-      end
-      def locate(node, position, node_types: [])
-        queue = T.let(node.child_nodes.compact, T::Array[T.nilable(SyntaxTree::Node)])
-        closest = node
-
-        until queue.empty?
-          candidate = queue.shift
-
-          # Skip nil child nodes
-          next if candidate.nil?
-
-          # Add the next child_nodes to the queue to be processed
-          queue.concat(candidate.child_nodes)
-
-          # Skip if the current node doesn't cover the desired position
-          loc = candidate.location
-          next unless (loc.start_char...loc.end_char).cover?(position)
-
-          # If the node's start character is already past the position, then we should've found the closest node already
-          break if position < loc.start_char
-
-          # If there are node types to filter by, and the current node is not one of those types, then skip it
-          next if node_types.any? && node_types.none? { |type| candidate.is_a?(type) }
-
-          # If the current node is narrower than or equal to the previous closest node, then it is more precise
-          closest_loc = closest.location
-          if loc.end_char - loc.start_char <= closest_loc.end_char - closest_loc.start_char
-            parent = T.let(closest, SyntaxTree::Node)
-            closest = candidate
-          end
-        end
-
-        [closest, parent]
-      end
-
-      sig { params(node: T.nilable(SyntaxTree::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
-      def visible?(node, range)
-        return true if range.nil?
-        return false if node.nil?
-
-        loc = node.location
-        range.cover?(loc.start_line - 1) && range.cover?(loc.end_line - 1)
-      end
     end
   end
 end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -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

@@ -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,135 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Code lens demo](../../misc/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 < 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(T.all(T::Array[Interface::CodeLens], Object)) }
+      def run
+        visit(@document.tree) if @document.parsed?
+        @results
+      end
+
+      sig { override.params(node: SyntaxTree::ClassDeclaration).void }
+      def visit_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"
+          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 { override.params(node: SyntaxTree::Command).void }
+      def visit_command(node)
+        if node.message.value == "public"
+          with_visiblity("public", node)
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::CallNode).void }
+      def visit_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)
+          end
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::VCall).void }
+      def visit_vcall(node)
+        vcall_value = node.value.value
+
+        if ACCESS_MODIFIERS.include?(vcall_value)
+          @modifier = 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)
+      end
+
+      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" },
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -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))) }

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -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

@@ -69,18 +69,18 @@ module RubyLsp
         end
       end
 
-      sig { params(uri: String, document: Document).void }
-      def initialize(uri, document)
+      sig { params(document: Document).void }
+      def initialize(document)
         super(document)
 
         # 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)
+        version_match = /(?<=%40)[\d.]+(?=\.rbi$)/.match(document.uri)
         @gem_version = T.let(version_match && version_match[0], T.nilable(String))
-        @links = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentLink])
+        @links = T.let([], T::Array[Interface::DocumentLink])
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentLink], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::DocumentLink], Object)) }
       def run
         visit(@document.tree) if @document.parsed?
         @links
@@ -91,12 +91,12 @@ module RubyLsp
         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(
+        @links << 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

@@ -66,12 +66,12 @@ 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
 
@@ -82,11 +82,11 @@ module RubyLsp
         @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
         @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)) }
+      sig { override.returns(T.all(T::Array[Interface::DocumentSymbol], Object)) }
       def run
         visit(@document.tree) if @document.parsed?
         @root.children
@@ -134,7 +134,9 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::DefNode).void }
       def visit_def(node)
-        if node.target&.value&.value == "self"
+        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
@@ -180,7 +182,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
-        kind = case node.value
+        value = node.value
+        kind = case value
         when SyntaxTree::Const
           :constant
         when SyntaxTree::CVar, SyntaxTree::IVar
@@ -190,10 +193,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 +208,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),

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -63,11 +63,11 @@ module RubyLsp
       def initialize(document)
         super
 
-        @ranges = T.let([], T::Array[LanguageServer::Protocol::Interface::FoldingRange])
+        @ranges = T.let([], T::Array[Interface::FoldingRange])
         @partial_range = T.let(nil, T.nilable(PartialRange))
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::FoldingRange], Object)) }
       def run
         if @document.parsed?
           visit(@document.tree)
@@ -161,9 +161,9 @@ module RubyLsp
           node.is_a?(SyntaxTree::Comment) && @end_line + 1 != node.location.start_line - 1
         end
 
-        sig { returns(LanguageServer::Protocol::Interface::FoldingRange) }
+        sig { returns(Interface::FoldingRange) }
         def to_range
-          LanguageServer::Protocol::Interface::FoldingRange.new(
+          Interface::FoldingRange.new(
             start_line: @start_line,
             end_line: @end_line,
             kind: @kind,
@@ -220,7 +220,8 @@ module RubyLsp
 
       sig { params(node: T.any(SyntaxTree::CallNode, SyntaxTree::CommandCall)).void }
       def add_call_range(node)
-        receiver = T.let(node.receiver, SyntaxTree::Node)
+        receiver = T.let(node.receiver, T.nilable(SyntaxTree::Node))
+
         loop do
           case receiver
           when SyntaxTree::CallNode
@@ -255,9 +256,10 @@ module RubyLsp
       def add_def_range(node)
         # For an endless method with no arguments, `node.params` returns `nil` for Ruby 3.0, but a `Syntax::Params`
         # for Ruby 3.1
-        return unless node.params
+        params = node.params
+        return unless params
 
-        params_location = node.params.location
+        params_location = params.location
 
         if params_location.start_line < params_location.end_line
           add_lines_range(params_location.end_line, node.location.end_line - 1)
@@ -276,7 +278,9 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Node, statements: SyntaxTree::Statements).void }
       def add_statements_range(node, statements)
-        add_lines_range(node.location.start_line, statements.body.last.location.end_line) unless statements.empty?
+        return if statements.empty?
+
+        add_lines_range(node.location.start_line, T.must(statements.body.last).location.end_line)
       end
 
       sig { params(node: SyntaxTree::StringConcat).void }
@@ -291,7 +295,7 @@ module RubyLsp
       def add_lines_range(start_line, end_line)
         return if start_line >= end_line
 
-        @ranges << LanguageServer::Protocol::Interface::FoldingRange.new(
+        @ranges << Interface::FoldingRange.new(
           start_line: start_line - 1,
           end_line: end_line - 1,
           kind: "region",

data/lib/ruby_lsp/requests/formatting.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/requests/support/rubocop_formatting_runner"
+require "ruby_lsp/requests/support/syntax_tree_formatting_runner"
 
 module RubyLsp
   module Requests
@@ -26,11 +27,11 @@ module RubyLsp
 
       extend T::Sig
 
-      sig { params(uri: String, document: Document, formatter: String).void }
-      def initialize(uri, document, formatter: "auto")
+      sig { params(document: Document, formatter: String).void }
+      def initialize(document, formatter: "auto")
         super(document)
 
-        @uri = uri
+        @uri = T.let(document.uri, String)
         @formatter = T.let(
           if formatter == "auto"
             defined?(Support::RuboCopFormattingRunner) ? "rubocop" : "syntax_tree"
@@ -73,7 +74,7 @@ module RubyLsp
         when "rubocop"
           Support::RuboCopFormattingRunner.instance.run(@uri, @document)
         when "syntax_tree"
-          SyntaxTree.format(@document.source)
+          Support::SyntaxTreeFormattingRunner.instance.run(@uri, @document)
         else
           raise InvalidFormatter, "Unknown formatter: #{@formatter}"
         end