holistic-ruby 0.1.0

data/lib/holistic/language_server/lifecycle.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  # Lifecycle constraints:
+  #
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#initialize
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#shutdown
+  class Lifecycle
+    UnexpectedStateError = ::Class.new(::StandardError)
+
+    attr_reader :state
+
+    def initialize
+      @state = :waiting_initialize_event
+    end
+
+    def waiting_initialized_event!
+      if @state != :waiting_initialize_event
+        raise UnexpectedStateError, "state must be :waiting_initialize_event, got: #{@state.inspect}"
+      end
+
+      @state = :waiting_initialized_event
+    end
+
+    def initialized!
+      if @state != :waiting_initialized_event
+        raise UnexpectedStateError, "state must be :waiting_initialized_event, got: #{@state.inspect}"
+      end
+
+      @state = :initialized
+    end
+
+    def shutdown!
+      if @state != :initialized
+        raise UnexpectedStateError, "state must be :initialized, got: #{@state.inspect}"
+      end
+
+      @state = :shutdown
+    end
+
+    def initialized?
+      @state == :initialized || @state == :shutdown
+    end
+
+    def accept?(method)
+      return true if method == "exit"
+      return true if method == "initialize" && @state == :waiting_initialize_event
+      return true if method == "initialized" && @state == :waiting_initialized_event
+      
+      return method != "initialize" && method != "initialized" if @state == :initialized
+
+      false
+    end
+
+    def reject?(method)
+      !accept?(method)
+    end
+  end
+end

data/lib/holistic/language_server/message.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  Message = ::Data.define(:data) do
+    def params
+      data["params"]
+    end
+
+    def param(*keys)
+      data["params"].dig(*keys)
+    end
+
+    def method
+      data["method"]
+    end
+
+    def id
+      data["id"]
+    end
+  end
+end

data/lib/holistic/language_server/protocol.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer::Protocol
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#abstractMessage
+  JSONRPC_VERSION = "2.0"
+
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#headerPart
+  END_OF_HEADER = "\r\n\r\n"
+  CONTENT_LENGTH_HEADER = "Content-Length"
+
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_synchronization
+  INCREMENTAL_TEXT_DOCUMENT_SYNCHRONIZATION = 2
+
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#responseMessage
+  REQUEST_FAILED_ERROR_CODE         = -32803
+  INVALID_REQUEST_ERROR_CODE        = -32600
+  SERVER_NOT_INITIALIZED_ERROR_CODE = -32002
+
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#completionItemKind
+  COMPLETION_ITEM_KIND_TEXT          = 1
+  COMPLETION_ITEM_KIND_METHOD        = 2
+  COMPLETION_ITEM_KIND_FUNCTION      = 3
+  COMPLETION_ITEM_KIND_CONSTRUCTOR   = 4
+  COMPLETION_ITEM_KIND_FIELD         = 5
+  COMPLETION_ITEM_KIND_VARIABLE      = 6
+  COMPLETION_ITEM_KIND_CLASS         = 7
+  COMPLETION_ITEM_KIND_INTERFACE     = 8
+  COMPLETION_ITEM_KIND_MODULE        = 9
+  COMPLETION_ITEM_KIND_PROPERTY      = 10
+  COMPLETION_ITEM_KIND_UNIT          = 11
+  COMPLETION_ITEM_KIND_VALUE         = 12
+  COMPLETION_ITEM_KIND_ENUM          = 13
+  COMPLETION_ITEM_KIND_KEYWORD       = 14
+  COMPLETION_ITEM_KIND_SNIPPET       = 15
+  COMPLETION_ITEM_KIND_COLOR         = 16
+  COMPLETION_ITEM_KIND_FILE          = 17
+  COMPLETION_ITEM_KIND_REFERENCE     = 18
+  COMPLETION_ITEM_KIND_FOLDER        = 19
+  COMPLETION_ITEM_KIND_ENUM_MEMBER   = 20
+  COMPLETION_ITEM_KIND_CONSTANT      = 21
+  COMPLETION_ITEM_KIND_STRUCT        = 22
+  COMPLETION_ITEM_KIND_EVENT         = 23
+  COMPLETION_ITEM_KIND_OPERATOR      = 24
+  COMPLETION_ITEM_KIND_TYPE_PARAMTER = 25
+end

data/lib/holistic/language_server/request.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  Request = ::Struct.new(:message, :application, :response, keyword_init: true) do
+    def respond_with(result)
+      self.response = Response::Success.new(message_id: message.id, result:)
+    end
+
+    def respond_with_error(code:, description: nil, data: nil)
+      self.response = Response::Error.new(message_id: message.id, code:, message: description, data:)
+    end
+
+    def drop
+      self.response = Response::Drop.new
+    end
+
+    def param(*keys)
+      message.param(*keys)
+    end
+  end
+end

data/lib/holistic/language_server/requests/lifecycle/exit.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#exit
+  module Requests::Lifecycle::Exit
+    extend self
+
+    def call(_request) = Response::Exit.new
+  end
+end

data/lib/holistic/language_server/requests/lifecycle/initialize.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#initialize
+  module Requests::Lifecycle::Initialize
+    extend self
+
+    # TODO: support multiple workspace directories.
+
+    def call(request)
+      application = create_application(request)
+
+      advance_lifecycle_state
+
+      parse_application_in_background(application)
+
+      respond_with_holistic_capabilities(request)
+    end
+
+    private
+
+    def create_application(request)
+      ::Holistic.logger.info("===========")
+      ::Holistic.logger.info(request.message.inspect)
+      
+      root_directory = request.param("rootPath")
+      name = ::File.basename(root_directory)
+
+      Current.application = ::Holistic::Application.new(name:, root_directory:)
+
+      ::Holistic::Extensions::Ruby::Stdlib.register(Current.application)
+
+      Current.application
+    end
+
+    def advance_lifecycle_state
+      Current.lifecycle.waiting_initialized_event!
+    end
+
+    def parse_application_in_background(application)
+      ::Holistic::BackgroundProcess.run do
+        ::Holistic::Ruby::Parser::ParseDirectory.call(application:, directory_path: application.root_directory)
+
+        ::Holistic::Ruby::TypeInference::SolvePendingReferences.call(application:)
+      end
+    end
+
+    def respond_with_holistic_capabilities(request)
+      request.respond_with({
+        capabilities: {
+          # Defines how the host (editor) should sync document changes to the language server.
+          # Incremental means documents are synced by sending the full content on open.
+          # After that only incremental updates to the document are sent.
+          textDocumentSync: Protocol::INCREMENTAL_TEXT_DOCUMENT_SYNCHRONIZATION,
+
+          # The server provides goto definition support.
+          definitionProvider: true,
+
+          # The server provides find references support.
+          referencesProvider: true,
+
+          # The server provides completion support
+          completionProvider: {
+            triggerCharacters: [".", "@"],
+            resolveProvider: true
+          }
+        },
+        serverInfo: {
+          name: "Holistic Ruby",
+          version: ::Holistic::VERSION
+        }
+      })
+    end
+  end
+end

data/lib/holistic/language_server/requests/lifecycle/initialized.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  module Requests::Lifecycle::Initialized
+    extend self
+
+    def call(request)
+      Current.lifecycle.initialized!
+
+      request.drop
+    end
+  end
+end

data/lib/holistic/language_server/requests/lifecycle/shutdown.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#shutdown
+  module Requests::Lifecycle::Shutdown
+    extend self
+
+    def call(request)
+      Current.lifecycle.shutdown!
+
+      request.respond_with(nil)
+    end
+  end
+end

data/lib/holistic/language_server/requests/text_document/completion.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  module Requests::TextDocument::Completion
+    extend self
+
+    def call(request)
+      cursor = build_cursor_from_request_params(request)
+
+      document = request.application.unsaved_documents.find(cursor.file_path)
+
+      return request.respond_with(nil) if document.nil?
+
+      if document.has_unsaved_changes?
+        ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(
+          application: request.application,
+          file: document.to_file
+        )
+      end
+
+      code = document.expand_code(cursor)
+      scope = request.application.scopes.find_inner_most_scope_by_cursor(cursor) || request.application.root_scope
+
+      return request.respond_with(nil) if code.blank?
+
+      suggestions = ::Holistic::Ruby::Autocompletion::Suggest.call(code:, scope:)
+
+      respond_with_suggestions(request, suggestions)
+    end
+
+    private
+
+    def build_cursor_from_request_params(request)
+      file_path = Format::FileUri.extract_path(request.param("textDocument", "uri"))
+      line = request.param("position", "line")
+      column = request.param("position", "character")
+
+      ::Holistic::Document::Cursor.new(file_path:, line:, column:)
+    end
+
+    module CompletionKind
+      FROM_SCOPE_TO_COMPLETION = {
+        ::Holistic::Ruby::Scope::Kind::CLASS  => Protocol::COMPLETION_ITEM_KIND_CLASS,
+        ::Holistic::Ruby::Scope::Kind::LAMBDA => Protocol::COMPLETION_ITEM_KIND_FUNCTION,
+        ::Holistic::Ruby::Scope::Kind::METHOD => Protocol::COMPLETION_ITEM_KIND_METHOD,
+        ::Holistic::Ruby::Scope::Kind::MODULE => Protocol::COMPLETION_ITEM_KIND_MODULE,
+        ::Holistic::Ruby::Scope::Kind::ROOT   => Protocol::COMPLETION_ITEM_KIND_MODULE
+      }.freeze
+
+      DEFAULT = Protocol::COMPLETION_ITEM_KIND_MODULE
+
+      def self.fetch(scope_kind)
+        FROM_SCOPE_TO_COMPLETION.fetch(scope_kind, DEFAULT)
+      end
+    end
+
+    def respond_with_suggestions(request, suggestions)
+      formatted_suggestions = suggestions.map do |suggestion|
+        {
+          label: suggestion.code,
+          kind: CompletionKind.fetch(suggestion.kind)
+        }
+      end
+
+      request.respond_with(formatted_suggestions)
+    end
+  end
+end

data/lib/holistic/language_server/requests/text_document/did_change.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  module Requests::TextDocument::DidChange
+    extend self
+
+    BuildDocumentChange = ->(params) do
+      ::Holistic::Document::Unsaved::Change.new(
+        range_length: params.dig("rangeLength"),
+        text: params.dig("text"),
+        start_line: params.dig("range", "start", "line"),
+        start_column: params.dig("range", "start", "character"),
+        end_line: params.dig("range", "end", "line"),
+        end_column: params.dig("range", "end", "character")
+      )
+    end
+
+    def call(request)
+      file_path = Format::FileUri.extract_path(request.param("textDocument", "uri"))
+
+      unsaved_document = request.application.unsaved_documents.find(file_path)
+
+      request.param("contentChanges").map(&BuildDocumentChange).each do |change|
+        unsaved_document.apply_change(change)
+      end
+
+      request.respond_with(nil)
+    end
+  end
+end

data/lib/holistic/language_server/requests/text_document/did_close.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  module Requests::TextDocument::DidClose
+    extend self
+
+    def call(request)
+      path = Format::FileUri.extract_path(request.message.param("textDocument", "uri"))
+
+      unsaved_document = request.application.unsaved_documents.find(path)
+
+      if unsaved_document.present?
+        request.application.unsaved_documents.delete(path)
+        
+        if unsaved_document.has_unsaved_changes?
+          unsaved_document.restore_original_content!
+
+          process_in_background(application: request.application, file: unsaved_document.to_file)
+        end
+      end
+
+      request.respond_with(nil)
+    end
+
+    private
+
+    def process_in_background(application:, file:)
+      ::Holistic::BackgroundProcess.run do
+        ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(application:, file:)
+      end
+    end
+  end
+end

data/lib/holistic/language_server/requests/text_document/did_open.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  module Requests::TextDocument::DidOpen
+    extend self
+
+    def call(request)
+      path = Format::FileUri.extract_path(request.message.param("textDocument", "uri"))
+      content = request.message.param("textDocument", "text")
+
+      request.application.unsaved_documents.add(path:, content:)
+
+      request.respond_with(nil)
+    end
+  end
+end

data/lib/holistic/language_server/requests/text_document/did_save.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  module Requests::TextDocument::DidSave
+    extend self
+
+    def call(request)
+      file_path = Format::FileUri.extract_path(request.param("textDocument", "uri"))
+      unsaved_document = request.application.unsaved_documents.find(file_path)
+
+      if unsaved_document.nil?
+        return request.respond_with_error(
+          code: Protocol::REQUEST_FAILED_ERROR_CODE,
+          description: "could not find document #{file_path} in the unsaved documents list"
+        )
+      end
+
+      unsaved_document.mark_as_saved!
+
+      process_in_background(application: request.application, file: unsaved_document.to_file)
+
+      request.respond_with(nil)
+    end
+
+    private
+
+    def process_in_background(application:, file:)
+      ::Holistic::BackgroundProcess.run do
+        ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(application:, file:)
+      end
+    end
+  end
+end

data/lib/holistic/language_server/requests/text_document/find_references.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_references
+  module Requests::TextDocument::FindReferences
+    extend self
+
+    def call(request)
+      cursor = build_cursor_from_params(request)
+
+      request.application.unsaved_documents.find(cursor.file_path)&.then do |unsaved_document|
+        if unsaved_document.has_unsaved_changes?
+          ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(
+            application: request.application,
+            file: unsaved_document.to_file
+          )
+        end
+      end
+
+      case ::Holistic::Ruby::Scope::ListReferences.call(application: request.application, cursor:)
+      in :not_found
+        request.respond_with(nil)
+      in [:references_listed, {references:}]
+        respond_with_locations(request, references)
+      end
+    end
+
+    private
+
+    def build_cursor_from_params(request)
+      file_path = Format::FileUri.extract_path(request.param("textDocument", "uri"))
+      line = request.param("position", "line")
+      column = request.param("position", "character")
+
+      ::Holistic::Document::Cursor.new(file_path:, line:, column:)
+    end
+
+    def respond_with_locations(request, references)
+      locations = references.map do |reference|
+        {
+          "uri" => Format::FileUri.from_path(reference.location.file_path),
+          "range" => {
+            "start" => { "line" => reference.location.start_line, "character" => reference.location.start_column },
+            "end" => { "line" => reference.location.end_line, "character" => reference.location.end_column }
+          }
+        }
+      end
+
+      request.respond_with(locations)
+    end
+  end
+end

data/lib/holistic/language_server/requests/text_document/go_to_definition.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_definition
+  module Requests::TextDocument::GoToDefinition
+    extend self
+
+    def call(request)
+      cursor = build_cursor_from_params(request)
+
+      request.application.unsaved_documents.find(cursor.file_path)&.then do |unsaved_document|
+        if unsaved_document.has_unsaved_changes?
+          ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(
+            application: request.application,
+            file: unsaved_document.to_file
+          )
+        end
+      end
+
+      case ::Holistic::Ruby::Reference::FindReferencedScope.call(application: request.application, cursor:)
+      in :not_found
+        request.respond_with(nil)
+      in :could_not_find_referenced_scope
+        request.respond_with(nil)
+      in [:referenced_scope_found, {reference:, referenced_scope:}]
+        respond_with_location_link(request, reference, referenced_scope)
+      end
+    end
+
+    private
+
+    def build_cursor_from_params(request)
+      file_path = Format::FileUri.extract_path(request.param("textDocument", "uri"))
+      line = request.param("position", "line")
+      column = request.param("position", "character")
+
+      ::Holistic::Document::Cursor.new(file_path:, line:, column:)
+    end
+
+    def respond_with_location_link(request, reference, referenced_scope)
+      origin_location = reference.location
+      target_declaration_location = referenced_scope.locations.main.declaration
+
+      location_link = {
+        "originSelectionRange" => {
+          "start" => { "line" => origin_location.start_line, "character" => origin_location.start_column },
+          "end" => { "line" => origin_location.end_line, "character" => origin_location.end_column }
+        },
+        "targetUri" => Format::FileUri.from_path(target_declaration_location.file_path),
+        "targetRange" => {
+          "start" => { "line" => target_declaration_location.start_line, "character" => target_declaration_location.start_column },
+          "end" => { "line" => target_declaration_location.end_line, "character" => target_declaration_location.end_column }
+        },
+        # TODO: store the location of the declaration name
+        "targetSelectionRange" => {
+          "start" => { "line" => target_declaration_location.start_line, "character" => target_declaration_location.start_column },
+          "end" => { "line" => target_declaration_location.end_line, "character" => target_declaration_location.end_column }
+        }
+      }
+
+      request.respond_with([location_link])
+    end
+  end
+end

data/lib/holistic/language_server/response.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  module Response
+    extend self
+    
+    Success = ::Data.define(:message_id, :result) do
+      def encode
+        encoded_payload = {
+          "jsonrpc" => Protocol::JSONRPC_VERSION,
+          "id"      => message_id,
+          "result"  => result
+        }.to_json
+
+        "#{Protocol::CONTENT_LENGTH_HEADER}:#{encoded_payload.bytesize}#{Protocol::END_OF_HEADER}#{encoded_payload}"
+      end
+    end
+
+    Error = ::Data.define(:message_id, :code, :message, :data) do
+      def encode
+        encoded_payload = {
+          "jsonrpc" => Protocol::JSONRPC_VERSION,
+          "id" => message_id,
+          "error" => {
+            "code" => code,
+            "message" => message,
+            "data" => data
+          }
+        }.to_json
+
+        "#{Protocol::CONTENT_LENGTH_HEADER}:#{encoded_payload.bytesize}#{Protocol::END_OF_HEADER}#{encoded_payload}"
+      end
+    end
+
+    Exit = ::Data.define
+    NotFound = ::Data.define
+    Drop = ::Data.define
+  end
+end

data/lib/holistic/language_server/router.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  module Router
+    extend self
+
+    ROUTES = {
+      "initialize"              => Requests::Lifecycle::Initialize,
+      "initialized"             => Requests::Lifecycle::Initialized,
+      "shutdown"                => Requests::Lifecycle::Shutdown,
+      "exit"                    => Requests::Lifecycle::Exit,
+      "textDocument/didOpen"    => Requests::TextDocument::DidOpen,
+      "textDocument/didChange"  => Requests::TextDocument::DidChange,
+      "textDocument/didSave"    => Requests::TextDocument::DidSave,
+      "textDocument/didClose"   => Requests::TextDocument::DidClose,
+      "textDocument/definition" => Requests::TextDocument::GoToDefinition,
+      "textDocument/references" => Requests::TextDocument::FindReferences,
+      "textDocument/completion" => Requests::TextDocument::Completion
+    }.freeze
+
+    def dispatch(message)
+      request = Request.new(message:, application: Current.application)
+
+      ::ActiveSupport::Notifications.instrument("holistic.language_server.request", request:) do
+        return respond_with_rejection(request) if Current.lifecycle.reject?(message.method)
+
+        handler = ROUTES[message.method]
+
+        return Response::NotFound.new if handler.nil?
+
+        handler.call(request)
+      end
+    end
+
+    private
+
+    def respond_with_rejection(request)
+      error_code =
+        if Current.lifecycle.initialized?
+          Protocol::INVALID_REQUEST_ERROR_CODE
+        else
+          Protocol::SERVER_NOT_INITIALIZED_ERROR_CODE
+        end
+
+      request.respond_with_error(code: error_code)
+    end
+  end
+end