ruby-lsp 0.0.1 → 0.0.4

data/lib/ruby_lsp/document.rb

@@ -0,0 +1,113 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class Document
+    extend T::Sig
+
+    PositionShape = T.type_alias { { line: Integer, character: Integer } }
+    RangeShape = T.type_alias { { start: PositionShape, end: PositionShape } }
+    EditShape = T.type_alias { { range: RangeShape, text: String } }
+
+    sig { returns(SyntaxTree::Node) }
+    attr_reader :tree
+
+    sig { returns(String) }
+    attr_reader :source
+
+    sig { returns(T::Array[EditShape]) }
+    attr_reader :syntax_error_edits
+
+    sig { params(source: String).void }
+    def initialize(source)
+      @tree = T.let(SyntaxTree.parse(source), SyntaxTree::Node)
+      @cache = T.let({}, T::Hash[Symbol, T.untyped])
+      @syntax_error_edits = T.let([], T::Array[EditShape])
+      @source = source
+      @parsable_source = T.let(source.dup, String)
+    end
+
+    sig { params(other: Document).returns(T::Boolean) }
+    def ==(other)
+      @source == other.source
+    end
+
+    sig { params(request_name: Symbol, block: T.proc.params(document: Document).returns(T.untyped)).returns(T.untyped) }
+    def cache_fetch(request_name, &block)
+      cached = @cache[request_name]
+      return cached if cached
+
+      result = block.call(self)
+      @cache[request_name] = result
+      result
+    end
+
+    sig { params(edits: T::Array[EditShape]).void }
+    def push_edits(edits)
+      # Apply the edits on the real source
+      edits.each { |edit| apply_edit(@source, edit[:range], edit[:text]) }
+
+      @cache.clear
+      @tree = SyntaxTree.parse(@source)
+      @syntax_error_edits.clear
+      @parsable_source = @source.dup
+      nil
+    rescue SyntaxTree::Parser::ParseError
+      update_parsable_source(edits)
+    end
+
+    sig { returns(T::Boolean) }
+    def syntax_errors?
+      @syntax_error_edits.any?
+    end
+
+    private
+
+    sig { params(edits: T::Array[EditShape]).void }
+    def update_parsable_source(edits)
+      # If the new edits caused a syntax error, make all edits blank spaces and line breaks to adjust the line and
+      # column numbers. This is attempt to make the document parsable while partial edits are being applied
+      edits.each do |edit|
+        @syntax_error_edits << edit
+        next if edit[:text].empty? # skip deletions, since they may have caused the syntax error
+
+        apply_edit(@parsable_source, edit[:range], edit[:text].gsub(/[^\r\n]/, " "))
+      end
+
+      @tree = SyntaxTree.parse(@parsable_source)
+    rescue SyntaxTree::Parser::ParseError
+      # If we can't parse the source even after emptying the edits, then just fallback to the previous source
+    end
+
+    sig { params(source: String, range: RangeShape, text: String).void }
+    def apply_edit(source, range, text)
+      scanner = Scanner.new(source)
+      start_position = scanner.find_position(range[:start])
+      end_position = scanner.find_position(range[:end])
+
+      source[start_position...end_position] = text
+    end
+
+    class Scanner
+      extend T::Sig
+
+      sig { params(source: String).void }
+      def initialize(source)
+        @current_line = T.let(0, Integer)
+        @pos = T.let(0, Integer)
+        @source = source
+      end
+
+      sig { params(position: PositionShape).returns(Integer) }
+      def find_position(position)
+        until @current_line == position[:line]
+          @pos += 1 until /\R/.match?(@source[@pos])
+          @pos += 1
+          @current_line += 1
+        end
+
+        @pos + position[:character]
+      end
+    end
+  end
+end

data/lib/ruby_lsp/handler.rb

@@ -0,0 +1,236 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "ruby_lsp/requests"
+require "ruby_lsp/store"
+require "benchmark"
+
+module RubyLsp
+  class Handler
+    extend T::Sig
+    VOID = T.let(Object.new.freeze, Object)
+
+    sig { returns(Store) }
+    attr_reader :store
+
+    Interface = LanguageServer::Protocol::Interface
+    Constant = LanguageServer::Protocol::Constant
+    Transport = LanguageServer::Protocol::Transport
+
+    sig { void }
+    def initialize
+      @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
+      @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
+      @handlers = T.let({}, T::Hash[String, T.proc.params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped)])
+      @store = T.let(Store.new, Store)
+    end
+
+    sig { void }
+    def start
+      $stderr.puts "Starting Ruby LSP..."
+      @reader.read do |request|
+        with_telemetry(request) { handle(request) }
+      end
+    end
+
+    sig { params(blk: T.proc.bind(Handler).params(arg0: T.untyped).void).void }
+    def config(&blk)
+      instance_exec(&blk)
+    end
+
+    private
+
+    sig do
+      params(
+        msg: String,
+        blk: T.proc.bind(Handler).params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped)
+      ).void
+    end
+    def on(msg, &blk)
+      @handlers[msg] = blk
+    end
+
+    sig { params(request: T::Hash[Symbol, T.untyped]).void }
+    def handle(request)
+      handler = @handlers[request[:method]]
+      return unless handler
+
+      result = handler.call(request)
+      @writer.write(id: request[:id], result: result) unless result == VOID
+    end
+
+    sig { void }
+    def shutdown
+      $stderr.puts "Shutting down Ruby LSP..."
+      store.clear
+    end
+
+    sig { params(enabled_features: T::Array[String]).returns(Interface::InitializeResult) }
+    def respond_with_capabilities(enabled_features)
+      document_symbol_provider = if enabled_features.include?("documentSymbols")
+        Interface::DocumentSymbolClientCapabilities.new(
+          hierarchical_document_symbol_support: true,
+          symbol_kind: {
+            value_set: Requests::DocumentSymbol::SYMBOL_KIND.values,
+          }
+        )
+      end
+
+      folding_ranges_provider = if enabled_features.include?("foldingRanges")
+        Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
+      end
+
+      semantic_tokens_provider = if enabled_features.include?("semanticHighlighting")
+        Interface::SemanticTokensRegistrationOptions.new(
+          document_selector: { scheme: "file", language: "ruby" },
+          legend: Interface::SemanticTokensLegend.new(
+            token_types: Requests::SemanticHighlighting::TOKEN_TYPES,
+            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS.keys
+          ),
+          range: false,
+          full: {
+            delta: true,
+          }
+        )
+      end
+
+      Interface::InitializeResult.new(
+        capabilities: Interface::ServerCapabilities.new(
+          text_document_sync: Interface::TextDocumentSyncOptions.new(
+            change: Constant::TextDocumentSyncKind::INCREMENTAL,
+            open_close: true,
+          ),
+          selection_range_provider: enabled_features.include?("selectionRanges"),
+          document_symbol_provider: document_symbol_provider,
+          folding_range_provider: folding_ranges_provider,
+          semantic_tokens_provider: semantic_tokens_provider,
+          document_formatting_provider: enabled_features.include?("formatting"),
+          document_highlight_provider: enabled_features.include?("documentHighlights"),
+          code_action_provider: enabled_features.include?("codeActions")
+        )
+      )
+    end
+
+    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol]) }
+    def respond_with_document_symbol(uri)
+      store.cache_fetch(uri, :document_symbol) do |document|
+        RubyLsp::Requests::DocumentSymbol.run(document)
+      end
+    end
+
+    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::FoldingRange]) }
+    def respond_with_folding_ranges(uri)
+      store.cache_fetch(uri, :folding_ranges) do |document|
+        Requests::FoldingRanges.run(document)
+      end
+    end
+
+    sig do
+      params(
+        uri: String,
+        positions: T::Array[Document::PositionShape]
+      ).returns(T::Array[RubyLsp::Requests::Support::SelectionRange])
+    end
+    def respond_with_selection_ranges(uri, positions)
+      ranges = store.cache_fetch(uri, :selection_ranges) do |document|
+        Requests::SelectionRanges.run(document)
+      end
+
+      # Per the selection range request spec (https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange),
+      # every position in the positions array should have an element at the same index in the response
+      # array. For positions without a valid selection range, the corresponding element in the response
+      # array will be nil.
+      positions.map do |position|
+        ranges.find do |range|
+          range.cover?(position)
+        end
+      end
+    end
+
+    sig { params(uri: String).returns(LanguageServer::Protocol::Interface::SemanticTokens) }
+    def respond_with_semantic_highlighting(uri)
+      store.cache_fetch(uri, :semantic_highlighting) do |document|
+        Requests::SemanticHighlighting.new(document, encoder: Requests::Support::SemanticTokenEncoder.new).run
+      end
+    end
+
+    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::TextEdit]) }
+    def respond_with_formatting(uri)
+      Requests::Formatting.run(uri, store.get(uri))
+    end
+
+    sig { params(uri: String).void }
+    def send_diagnostics(uri)
+      response = store.cache_fetch(uri, :diagnostics) do |document|
+        Requests::Diagnostics.run(uri, document)
+      end
+
+      @writer.write(
+        method: "textDocument/publishDiagnostics",
+        params: Interface::PublishDiagnosticsParams.new(
+          uri: uri,
+          diagnostics: response.map(&:to_lsp_diagnostic)
+        )
+      )
+    end
+
+    sig do
+      params(uri: String, range: T::Range[Integer]).returns(T::Array[LanguageServer::Protocol::Interface::Diagnostic])
+    end
+    def respond_with_code_actions(uri, range)
+      store.cache_fetch(uri, :code_actions) do |document|
+        Requests::CodeActions.run(uri, document, range)
+      end
+    end
+
+    sig do
+      params(
+        uri: String,
+        position: Document::PositionShape
+      ).returns(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
+    end
+    def respond_with_document_highlight(uri, position)
+      Requests::DocumentHighlight.run(store.get(uri), position)
+    end
+
+    sig { params(request: T::Hash[Symbol, T.untyped], block: T.proc.void).returns(T.untyped) }
+    def with_telemetry(request, &block)
+      result = T.let(nil, T.untyped)
+      error = T.let(nil, T.nilable(StandardError))
+
+      request_time = Benchmark.realtime do
+        result = block.call
+      rescue StandardError => e
+        error = e
+      end
+
+      @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
+      result
+    end
+
+    sig do
+      params(
+        request: T::Hash[Symbol, T.untyped],
+        request_time: Float,
+        error: T.nilable(StandardError)
+      ).returns(T::Hash[Symbol, T.any(String, Float)])
+    end
+    def telemetry_params(request, request_time, error)
+      uri = request.dig(:params, :textDocument, :uri)
+
+      params = {
+        request: request[:method],
+        lspVersion: RubyLsp::VERSION,
+        requestTime: request_time,
+      }
+
+      if error
+        params[:errorClass] = error.class.name
+        params[:errorMessage] = error.message
+      end
+
+      params[:uri] = uri if uri
+      params
+    end
+  end
+end

data/lib/ruby_lsp/requests/base_request.rb

@@ -0,0 +1,33 @@
+# typed: true
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # :nodoc:
+    class BaseRequest < SyntaxTree::Visitor
+      def self.run(document)
+        new(document).run
+      end
+
+      def initialize(document)
+        @document = document
+
+        super()
+      end
+
+      def run
+        raise NotImplementedError, "#{self.class}#run must be implemented"
+      end
+
+      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
+    end
+  end
+end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -0,0 +1,37 @@
+# typed: true
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # 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 accesible by hovering over a
+    # specific diagnostic.
+    #
+    # # Example
+    #
+    # ```ruby
+    # def say_hello
+    # puts "Hello" # --> code action: quick fix indentation
+    # end
+    # ```
+    class CodeActions
+      def self.run(uri, document, range)
+        new(uri, document, range).run
+      end
+
+      def initialize(uri, document, range)
+        @document = document
+        @uri = uri
+        @range = range
+      end
+
+      def run
+        diagnostics = Diagnostics.run(@uri, @document)
+        corrections = diagnostics.select { |diagnostic| diagnostic.correctable? && diagnostic.in_range?(@range) }
+        return [] if corrections.empty?
+
+        corrections.map!(&:to_lsp_code_action)
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -0,0 +1,37 @@
+# typed: true
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The
+    # [diagnostics](https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics)
+    # request informs the editor of RuboCop offenses for a given file.
+    #
+    # # Example
+    #
+    # ```ruby
+    # def say_hello
+    # puts "Hello" # --> diagnostics: incorrect indentantion
+    # end
+    # ```
+    class Diagnostics < RuboCopRequest
+      def run
+        return syntax_error_diagnostics if @document.syntax_errors?
+
+        super
+
+        @diagnostics
+      end
+
+      def file_finished(_file, offenses)
+        @diagnostics = offenses.map { |offense| Support::RuboCopDiagnostic.new(offense, @uri) }
+      end
+
+      private
+
+      def syntax_error_diagnostics
+        @document.syntax_error_edits.map { |e| Support::SyntaxErrorDiagnostic.new(e) }
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -0,0 +1,96 @@
+# typed: true
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # 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
+    # the cursor is on the `F` of the constant `FOO`, the editor should identify other occurences of `FOO`
+    # and highlight them.
+    #
+    # For writable elements like constants or variables, their read/write occurrences should be highlighted differently.
+    # This is achieved by sending different "kind" attributes to the editor (2 for read and 3 for write).
+    #
+    # # Example
+    #
+    # ```ruby
+    # FOO = 1 # should be highlighted as "write"
+    #
+    # def foo
+    #   FOO # should be highlighted as "read"
+    # end
+    # ```
+    class DocumentHighlight < BaseRequest
+      def self.run(document, position)
+        new(document, position).run
+      end
+
+      def initialize(document, position)
+        @highlights = []
+        position = Document::Scanner.new(document.source).find_position(position)
+        @target = find(document.tree, position)
+
+        super(document)
+      end
+
+      def run
+        # no @target means the target is not highlightable
+        return [] unless @target
+
+        visit(@document.tree)
+        @highlights
+      end
+
+      def visit_var_field(node)
+        if matches_target?(node.value)
+          add_highlight(
+            node.value,
+            LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
+          )
+        end
+
+        super
+      end
+
+      def visit_var_ref(node)
+        if matches_target?(node.value)
+          add_highlight(
+            node.value,
+            LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
+          )
+        end
+
+        super
+      end
+
+      private
+
+      def find(node, position)
+        matched =
+          node.child_nodes.compact.bsearch do |child|
+            if (child.location.start_char...child.location.end_char).cover?(position)
+              0
+            else
+              position <=> child.location.start_char
+            end
+          end
+
+        case matched
+        when SyntaxTree::GVar, SyntaxTree::Ident, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar
+          matched
+        when SyntaxTree::Node
+          find(matched, position)
+        end
+      end
+
+      def matches_target?(node)
+        node.is_a?(@target.class) && node.value == @target.value
+      end
+
+      def add_highlight(node, kind)
+        range = range_from_syntax_tree_node(node)
+        @highlights << LanguageServer::Protocol::Interface::DocumentHighlight.new(range: range, kind: kind)
+      end
+    end
+  end
+end