ruby-lsp 0.4.2 → 0.4.4

data/lib/ruby_lsp/requests/hover.rb

@@ -17,8 +17,11 @@ module RubyLsp
     #   before_save :do_something # when hovering on before_save, the link will be rendered
     # end
     # ```
-    class Hover < BaseRequest
+    class Hover < Listener
       extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T.nilable(Interface::Hover) } }
 
       ALLOWED_TARGETS = T.let(
         [
@@ -29,52 +32,45 @@ module RubyLsp
         T::Array[T.class_of(SyntaxTree::Node)],
       )
 
-      sig { params(document: Document, position: Document::PositionShape).void }
-      def initialize(document, position)
-        super(document)
+      sig { override.returns(ResponseType) }
+      attr_reader :response
 
-        @position = T.let(document.create_scanner.find_char_position(position), Integer)
+      sig { void }
+      def initialize
+        @response = T.let(nil, ResponseType)
+        super()
       end
 
-      sig { override.returns(T.nilable(LanguageServer::Protocol::Interface::Hover)) }
-      def run
-        return unless @document.parsed?
+      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
 
-        target, parent = locate(T.must(@document.tree), @position)
-        target = parent if !ALLOWED_TARGETS.include?(target.class) && ALLOWED_TARGETS.include?(parent.class)
+        sig { params(node: SyntaxTree::ConstPathRef).void }
+        def on_const_path_ref(node)
+          @response = generate_rails_document_link_hover(full_constant_name(node), node)
+        end
 
-        case target
-        when SyntaxTree::Command
-          message = target.message
-          generate_rails_document_link_hover(message.value, message)
-        when SyntaxTree::CallNode
-          return if target.message == :call
+        sig { params(node: SyntaxTree::CallNode).void }
+        def on_call(node)
+          message = node.message
+          return if message.is_a?(Symbol)
 
-          generate_rails_document_link_hover(target.message.value, target.message)
-        when SyntaxTree::ConstPathRef
-          constant_name = full_constant_name(target)
-          generate_rails_document_link_hover(constant_name, target)
+          @response = generate_rails_document_link_hover(message.value, message)
         end
       end
 
       private
 
-      sig do
-        params(name: String, node: SyntaxTree::Node).returns(T.nilable(LanguageServer::Protocol::Interface::Hover))
-      end
+      sig { params(name: String, node: SyntaxTree::Node).returns(T.nilable(Interface::Hover)) }
       def generate_rails_document_link_hover(name, node)
         urls = Support::RailsDocumentClient.generate_rails_document_urls(name)
-
         return if urls.empty?
 
-        contents = LanguageServer::Protocol::Interface::MarkupContent.new(
-          kind: "markdown",
-          value: urls.join("\n\n"),
-        )
-        LanguageServer::Protocol::Interface::Hover.new(
-          range: range_from_syntax_tree_node(node),
-          contents: contents,
-        )
+        contents = Interface::MarkupContent.new(kind: "markdown", value: urls.join("\n\n"))
+        Interface::Hover.new(range: range_from_syntax_tree_node(node), contents: contents)
       end
     end
   end

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -25,11 +25,11 @@ module RubyLsp
       def initialize(document, range)
         super(document)
 
-        @hints = T.let([], T::Array[LanguageServer::Protocol::Interface::InlayHint])
+        @hints = T.let([], T::Array[Interface::InlayHint])
         @range = range
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::InlayHint], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::InlayHint], Object)) }
       def run
         visit(@document.tree) if @document.parsed?
         @hints
@@ -37,12 +37,13 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Rescue).void }
       def visit_rescue(node)
-        return unless node.exception.nil?
+        exception = node.exception
+        return unless exception.nil? || exception.exceptions.nil?
 
         loc = node.location
         return unless visible?(node, @range)
 
-        @hints << LanguageServer::Protocol::Interface::InlayHint.new(
+        @hints << Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },
           label: "StandardError",
           padding_left: true,

data/lib/ruby_lsp/requests/path_completion.rb

@@ -29,8 +29,7 @@ module RubyLsp
         # We can't verify if we're inside a require when there are syntax errors
         return [] if @document.syntax_error?
 
-        char_position = @document.create_scanner.find_char_position(@position)
-        target = T.let(find(char_position), T.nilable(SyntaxTree::TStringContent))
+        target = T.let(find, T.nilable(SyntaxTree::TStringContent))
         # no target means the we are not inside a `require` call
         return [] unless target
 
@@ -51,11 +50,12 @@ module RubyLsp
         end
       end
 
-      sig { params(position: Integer).returns(T.nilable(SyntaxTree::TStringContent)) }
-      def find(position)
-        matched, parent = locate(
+      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),
-          position,
+          char_position,
           node_types: [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode],
         )
 
@@ -63,14 +63,20 @@ module RubyLsp
 
         case matched
         when SyntaxTree::Command, SyntaxTree::CallNode, SyntaxTree::CommandCall
-          return unless matched.message.value == "require"
+          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 = args.parts.first.parts.first
-          return unless path_node
-          return unless (path_node.location.start_char..path_node.location.end_char).cover?(position)
+          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

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -100,12 +100,12 @@ module RubyLsp
       end
       def create_selection_range(location, parent = nil)
         RubyLsp::Requests::Support::SelectionRange.new(
-          range: LanguageServer::Protocol::Interface::Range.new(
-            start: LanguageServer::Protocol::Interface::Position.new(
+          range: Interface::Range.new(
+            start: Interface::Position.new(
               line: location.start_line - 1,
               character: location.start_column,
             ),
-            end: LanguageServer::Protocol::Interface::Position.new(
+            end: Interface::Position.new(
               line: location.end_line - 1,
               character: location.end_column,
             ),

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -122,7 +122,7 @@ module RubyLsp
       sig do
         override.returns(
           T.any(
-            LanguageServer::Protocol::Interface::SemanticTokens,
+            Interface::SemanticTokens,
             T.all(T::Array[SemanticToken], Object),
           ),
         )
@@ -143,7 +143,7 @@ module RubyLsp
         visit(node.receiver)
 
         message = node.message
-        if message != :call && !special_method?(message.value)
+        if !message.is_a?(Symbol) && !special_method?(message.value)
           type = Support::Sorbet.annotation?(node) ? :type : :method
 
           add_token(message.location, type)
@@ -168,7 +168,8 @@ module RubyLsp
         return super unless visible?(node, @range)
 
         visit(node.receiver)
-        add_token(node.message.location, :method)
+        message = node.message
+        add_token(message.location, :method) unless message.is_a?(Symbol)
         visit(node.arguments)
         visit(node.block)
       end
@@ -205,7 +206,7 @@ module RubyLsp
       def visit_params(node)
         return super unless visible?(node, @range)
 
-        node.keywords.each do |keyword,|
+        node.keywords.each do |keyword, *|
           location = keyword.location
           add_token(location_without_colon(location), :parameter)
         end
@@ -215,7 +216,7 @@ module RubyLsp
         end
 
         rest = node.keyword_rest
-        if rest && !rest.is_a?(SyntaxTree::ArgsForward)
+        if rest && !rest.is_a?(SyntaxTree::ArgsForward) && !rest.is_a?(Symbol)
           name = rest.name
           add_token(name.location, :parameter) if name
         end
@@ -238,9 +239,14 @@ module RubyLsp
 
         value = node.value
 
-        if value.is_a?(SyntaxTree::Ident)
+        case value
+        when SyntaxTree::Ident
           type = type_for_local(value)
           add_token(value.location, type)
+        when Symbol
+          # do nothing
+        else
+          visit(value)
         end
 
         super
@@ -256,6 +262,8 @@ module RubyLsp
         when SyntaxTree::Ident
           type = type_for_local(value)
           add_token(value.location, type)
+        when Symbol
+          # do nothing
         else
           visit(value)
         end
@@ -305,18 +313,21 @@ module RubyLsp
         return unless node.operator == :=~
 
         left = node.left
+        # The regexp needs to be on the left hand side of the =~ for local variable capture
+        return unless left.is_a?(SyntaxTree::RegexpLiteral)
+
         parts = left.parts
+        return unless parts.one?
 
-        if left.is_a?(SyntaxTree::RegexpLiteral) && parts.one? && parts.first.is_a?(SyntaxTree::TStringContent)
-          content = parts.first
+        content = parts.first
+        return unless content.is_a?(SyntaxTree::TStringContent)
 
-          # For each capture name we find in the regexp, look for a local in the current_scope
-          Regexp.new(content.value, Regexp::FIXEDENCODING).names.each do |name|
-            local = current_scope.find_local(name)
-            next unless local
+        # For each capture name we find in the regexp, look for a local in the current_scope
+        Regexp.new(content.value, Regexp::FIXEDENCODING).names.each do |name|
+          local = current_scope.find_local(name)
+          next unless local
 
-            local.definitions.each { |definition| add_token(definition, :variable) }
-          end
+          local.definitions.each { |definition| add_token(definition, :variable) }
         end
       end
 
@@ -325,7 +336,10 @@ module RubyLsp
         return super unless visible?(node, @range)
 
         add_token(node.constant.location, :class, [:declaration])
-        add_token(node.superclass.location, :class) if node.superclass
+
+        superclass = node.superclass
+        add_token(superclass.location, :class) if superclass
+
         visit(node.bodystmt)
       end
 

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

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      module Common
+        extend T::Sig
+
+        sig { params(node: SyntaxTree::Node).returns(Interface::Range) }
+        def range_from_syntax_tree_node(node)
+          loc = node.location
+
+          Interface::Range.new(
+            start: Interface::Position.new(
+              line: loc.start_line - 1,
+              character: loc.start_column,
+            ),
+            end: 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 { 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
+end

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

@@ -7,8 +7,8 @@ module RubyLsp
       class HighlightTarget
         extend T::Sig
 
-        READ = LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
-        WRITE = LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
+        READ = Constant::DocumentHighlightKind::READ
+        WRITE = Constant::DocumentHighlightKind::WRITE
 
         class HighlightMatch
           extend T::Sig
@@ -84,10 +84,11 @@ module RubyLsp
                SyntaxTree::KwRestParam, SyntaxTree::BlockArg
             node.name&.value
           when SyntaxTree::VarField, SyntaxTree::VarRef, SyntaxTree::VCall
-            node.value&.value
+            value = node.value
+            value.value unless value.nil? || value.is_a?(Symbol)
           when SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall
             message = node.message
-            message != :call ? message.value : nil
+            message.value unless message.is_a?(Symbol)
           when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
             node.constant.constant.value
           end

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

@@ -67,12 +67,13 @@ module RubyLsp
             return unless RAILTIES_VERSION
 
             warn("Fetching Rails Documents...")
-            # If the version's doc is not found, e.g. Rails main, it'll be redirected
-            # In this case, we just fetch the latest doc
-            response = if Gem::Version.new(RAILTIES_VERSION).prerelease?
-              Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/js/search_index.js"))
-            else
-              Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/js/search_index.js"))
+
+            response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/js/search_index.js"))
+
+            if response.code == "302"
+              # If the version's doc is not found, e.g. Rails main, it'll be redirected
+              # In this case, we just fetch the latest doc
+              response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/js/search_index.js"))
             end
 
             if response.code == "200"

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

@@ -4,7 +4,7 @@
 module RubyLsp
   module Requests
     module Support
-      class SelectionRange < LanguageServer::Protocol::Interface::SelectionRange
+      class SelectionRange < Interface::SelectionRange
         extend T::Sig
 
         sig { params(position: Document::PositionShape).returns(T::Boolean) }

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

@@ -16,7 +16,7 @@ module RubyLsp
         sig do
           params(
             tokens: T::Array[SemanticHighlighting::SemanticToken],
-          ).returns(LanguageServer::Protocol::Interface::SemanticTokens)
+          ).returns(Interface::SemanticTokens)
         end
         def encode(tokens)
           delta = tokens
@@ -27,7 +27,7 @@ module RubyLsp
               compute_delta(token)
             end
 
-          LanguageServer::Protocol::Interface::SemanticTokens.new(data: delta)
+          Interface::SemanticTokens.new(data: delta)
         end
 
         # The delta array is computed according to the LSP specification:

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

@@ -63,7 +63,8 @@ module RubyLsp
             when SyntaxTree::VCall
               ANNOTATIONS[node.value.value]
             when SyntaxTree::CallNode
-              ANNOTATIONS[node.message.value]
+              message = node.message
+              ANNOTATIONS[message.value] unless message.is_a?(Symbol)
             else
               T.absurd(node)
             end
@@ -84,21 +85,10 @@ module RubyLsp
           end
 
           sig do
-            params(node: T.nilable(T.any(
-              SyntaxTree::VarRef,
-              SyntaxTree::CallNode,
-              SyntaxTree::VCall,
-              SyntaxTree::Ident,
-              SyntaxTree::Backtick,
-              SyntaxTree::Const,
-              SyntaxTree::Op,
-              Symbol,
-            ))).returns(T.nilable(String))
+            params(node: T.nilable(SyntaxTree::Node)).returns(T.nilable(String))
           end
           def node_name(node)
             case node
-            when NilClass
-              nil
             when SyntaxTree::VarRef
               node.value.value
             when SyntaxTree::CallNode
@@ -107,8 +97,8 @@ module RubyLsp
               node_name(node.value)
             when SyntaxTree::Ident, SyntaxTree::Backtick, SyntaxTree::Const, SyntaxTree::Op
               node.value
-            when Symbol
-              node.to_s
+            when NilClass, SyntaxTree::Node
+              nil
             else
               T.absurd(node)
             end

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

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "syntax_tree/cli"
+require "singleton"
+
+module RubyLsp
+  module Requests
+    module Support
+      # :nodoc:
+      class SyntaxTreeFormattingRunner
+        extend T::Sig
+        include Singleton
+
+        sig { void }
+        def initialize
+          @options =
+            T.let(
+              begin
+                opts = SyntaxTree::CLI::Options.new
+                opts.parse(SyntaxTree::CLI::ConfigFile.new.arguments)
+                opts
+              end,
+              SyntaxTree::CLI::Options,
+            )
+        end
+
+        sig { params(_uri: String, document: Document).returns(T.nilable(String)) }
+        def run(_uri, document)
+          SyntaxTree.format(
+            document.source,
+            @options.print_width,
+            options: @options.formatter_options,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -18,6 +18,7 @@ module RubyLsp
   # - {RubyLsp::Requests::DocumentHighlight}
   # - {RubyLsp::Requests::InlayHints}
   # - {RubyLsp::Requests::PathCompletion}
+  # - {RubyLsp::Requests::CodeLens}
 
   module Requests
     autoload :BaseRequest, "ruby_lsp/requests/base_request"
@@ -35,6 +36,7 @@ module RubyLsp
     autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
     autoload :InlayHints, "ruby_lsp/requests/inlay_hints"
     autoload :PathCompletion, "ruby_lsp/requests/path_completion"
+    autoload :CodeLens, "ruby_lsp/requests/code_lens"
 
     # :nodoc:
     module Support
@@ -46,6 +48,7 @@ module RubyLsp
       autoload :HighlightTarget, "ruby_lsp/requests/support/highlight_target"
       autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
       autoload :PrefixTree, "ruby_lsp/requests/support/prefix_tree"
+      autoload :Common, "ruby_lsp/requests/support/common"
     end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -2,9 +2,11 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # rubocop:disable RubyLsp/UseLanguageServerAliases
   Interface = LanguageServer::Protocol::Interface
   Constant = LanguageServer::Protocol::Constant
   Transport = LanguageServer::Protocol::Transport
+  # rubocop:enable RubyLsp/UseLanguageServerAliases
 
   class Server
     extend T::Sig
@@ -33,7 +35,8 @@ module RubyLsp
       # fall under the else branch which just pushes requests to the queue
       @reader.read do |request|
         case request[:method]
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
+              "textDocument/formatting", "textDocument/onTypeFormatting", "codeAction/resolve"
           result = Executor.new(@store).execute(request)
           finalize_request(result, request)
         when "$/cancelRequest"

data/lib/ruby_lsp/store.rb

@@ -9,8 +9,8 @@ module RubyLsp
   class Store
     extend T::Sig
 
-    sig { params(encoding: String).void }
-    attr_writer :encoding
+    sig { returns(String) }
+    attr_accessor :encoding
 
     sig { returns(String) }
     attr_accessor :formatter
@@ -18,7 +18,7 @@ module RubyLsp
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document])
-      @encoding = T.let("utf-8", String)
+      @encoding = T.let(Constant::PositionEncodingKind::UTF8, String)
       @formatter = T.let("auto", String)
     end
 
@@ -27,19 +27,19 @@ module RubyLsp
       document = @state[uri]
       return document unless document.nil?
 
-      set(uri, File.binread(CGI.unescape(URI.parse(uri).path)))
+      set(uri: uri, source: File.binread(CGI.unescape(URI.parse(uri).path)), version: 0)
       T.must(@state[uri])
     end
 
-    sig { params(uri: String, content: String).void }
-    def set(uri, content)
-      document = Document.new(content, @encoding)
+    sig { params(uri: String, source: String, version: Integer).void }
+    def set(uri:, source:, version:)
+      document = Document.new(source: source, version: version, uri: uri, encoding: @encoding)
       @state[uri] = document
     end
 
-    sig { params(uri: String, edits: T::Array[Document::EditShape]).void }
-    def push_edits(uri, edits)
-      T.must(@state[uri]).push_edits(edits)
+    sig { params(uri: String, edits: T::Array[Document::EditShape], version: Integer).void }
+    def push_edits(uri:, edits:, version:)
+      T.must(@state[uri]).push_edits(edits, version: version)
     end
 
     sig { void }