refined-steep-server 0.1.0

data/lib/refined/steep/server/message.rb

@@ -0,0 +1,150 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Refined
+  module Steep
+    module Server
+      Interface = LanguageServer::Protocol::Interface
+      Constant = LanguageServer::Protocol::Constant
+      Transport = LanguageServer::Protocol::Transport
+
+      class Message
+        attr_reader :method #: String
+        attr_reader :params #: untyped
+
+        # @rbs method: String
+        # @rbs params: untyped
+        # @rbs return: void
+        def initialize(method:, params:)
+          @method = method
+          @params = params
+        end
+
+        # @rbs return: Hash[Symbol, untyped]
+        def to_hash
+          raise NotImplementedError
+        end
+      end
+
+      class Notification < Message
+        class << self
+          # @rbs message: String
+          # @rbs type: Integer
+          # @rbs return: Notification
+          def window_show_message(message, type: Constant::MessageType::INFO)
+            new(
+              method: "window/showMessage",
+              params: Interface::ShowMessageParams.new(type: type, message: message),
+            )
+          end
+
+          # @rbs message: String
+          # @rbs type: Integer
+          # @rbs return: Notification
+          def window_log_message(message, type: Constant::MessageType::LOG)
+            new(
+              method: "window/logMessage",
+              params: Interface::LogMessageParams.new(type: type, message: message),
+            )
+          end
+
+          # @rbs uri: String
+          # @rbs diagnostics: Array[untyped]
+          # @rbs version: Integer?
+          # @rbs return: Notification
+          def publish_diagnostics(uri, diagnostics, version: nil)
+            new(
+              method: "textDocument/publishDiagnostics",
+              params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: diagnostics, version: version),
+            )
+          end
+        end
+
+        # @rbs return: Hash[Symbol, untyped]
+        def to_hash
+          hash = { method: @method } #: Hash[Symbol, untyped]
+
+          if @params
+            hash[:params] = @params.to_hash
+          end
+
+          hash
+        end
+      end
+
+      class Request < Message
+        # @rbs @id: Integer | String
+
+        # @rbs id: Integer | String
+        # @rbs method: String
+        # @rbs params: untyped
+        # @rbs return: void
+        def initialize(id:, method:, params:)
+          @id = id
+          super(method: method, params: params)
+        end
+
+        # @rbs return: Hash[Symbol, untyped]
+        def to_hash
+          hash = { id: @id, method: @method } #: Hash[Symbol, untyped]
+
+          if @params
+            hash[:params] = @params.to_hash
+          end
+
+          hash
+        end
+      end
+
+      class ErrorResponse
+        # @rbs @id: Integer
+        # @rbs @data: Hash[Symbol, untyped]?
+
+        attr_reader :message #: String
+        attr_reader :code #: Integer
+
+        # @rbs id: Integer
+        # @rbs code: Integer
+        # @rbs message: String
+        # @rbs data: Hash[Symbol, untyped]?
+        # @rbs return: void
+        def initialize(id:, code:, message:, data: nil)
+          @id = id
+          @code = code
+          @message = message
+          @data = data
+        end
+
+        # @rbs return: Hash[Symbol, untyped]
+        def to_hash
+          {
+            id: @id,
+            error: {
+              code: @code,
+              message: @message,
+              data: @data,
+            },
+          }
+        end
+      end
+
+      class Result
+        attr_reader :response #: untyped
+        attr_reader :id #: Integer
+
+        # @rbs id: Integer
+        # @rbs response: untyped
+        # @rbs return: void
+        def initialize(id:, response:)
+          @id = id
+          @response = response
+        end
+
+        # @rbs return: Hash[Symbol, untyped]
+        def to_hash
+          { id: @id, result: @response }
+        end
+      end
+    end
+  end
+end

data/lib/refined/steep/server/steep_state.rb

@@ -0,0 +1,80 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Refined
+  module Steep
+    module Server
+      class SteepState
+        # @rbs @buffered_changes: Hash[Pathname, Array[::Steep::Services::ContentChange]]
+
+        attr_reader :project #: ::Steep::Project
+        attr_reader :type_check_service #: ::Steep::Services::TypeCheckService
+        attr_reader :assignment #: ::Steep::Services::PathAssignment
+        attr_reader :mutex #: Mutex
+
+        # @rbs steepfile_path: Pathname
+        # @rbs return: void
+        def initialize(steepfile_path:)
+          @mutex = Mutex.new
+          @project = load_project(steepfile_path)
+          @type_check_service = ::Steep::Services::TypeCheckService.new(project: @project)
+          @assignment = ::Steep::Services::PathAssignment.all
+          @buffered_changes = {}
+        end
+
+        # @rbs path: Pathname
+        # @rbs changes: Array[::Steep::Services::ContentChange]
+        # @rbs return: void
+        def push_changes(path, changes)
+          @mutex.synchronize do
+            existing = @buffered_changes[path]
+            unless existing
+              existing = [] #: Array[::Steep::Services::ContentChange]
+              @buffered_changes[path] = existing
+            end
+            existing.concat(changes)
+          end
+        end
+
+        # @rbs return: Hash[Pathname, Array[::Steep::Services::ContentChange]]
+        def flush_changes
+          @mutex.synchronize do
+            copy = @buffered_changes.dup
+            @buffered_changes.clear
+            copy
+          end
+        end
+
+        # @rbs return: void
+        def apply_changes
+          changes = flush_changes
+          type_check_service.update(changes: changes) unless changes.empty?
+        end
+
+        # @rbs path: Pathname
+        # @rbs return: ::Steep::Project::Target?
+        def target_for_path(path)
+          project.target_for_source_path(path) ||
+            project.target_for_signature_path(path)
+        end
+
+        # @rbs target_name: Symbol
+        # @rbs return: ::Steep::Services::SignatureService?
+        def signature_service_for(target_name)
+          type_check_service.signature_services[target_name]
+        end
+
+        private
+
+        # @rbs steepfile_path: Pathname
+        # @rbs return: ::Steep::Project
+        def load_project(steepfile_path)
+          path = steepfile_path.expand_path
+          ::Steep::Project.new(steepfile_path: path).tap do |project|
+            ::Steep::Project::DSL.parse(project, path.read, filename: path.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/refined/steep/server/store.rb

@@ -0,0 +1,113 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Refined
+  module Steep
+    module Server
+      class Store
+        class DocumentEntry
+          attr_reader :uri #: String
+          attr_reader :content #: String
+          attr_reader :version #: Integer
+
+          # @rbs uri: String
+          # @rbs content: String
+          # @rbs version: Integer
+          # @rbs return: void
+          def initialize(uri:, content:, version:)
+            @uri = uri
+            @content = content
+            @version = version
+          end
+        end
+
+        # @rbs @steep_state: SteepState
+        # @rbs @documents: Hash[String, DocumentEntry]
+
+        # @rbs steep_state: SteepState
+        # @rbs return: void
+        def initialize(steep_state)
+          @steep_state = steep_state
+          @documents = {}
+        end
+
+        # @rbs uri: String
+        # @rbs text: String
+        # @rbs version: Integer
+        # @rbs return: void
+        def open(uri:, text:, version:)
+          @documents[uri] = DocumentEntry.new(uri: uri, content: text, version: version)
+
+          path = uri_to_relative_path(uri)
+          return unless path
+
+          @steep_state.push_changes(path, [
+            ::Steep::Services::ContentChange.new(text: text),
+          ])
+        end
+
+        # @rbs uri: String
+        # @rbs content_changes: Array[Hash[Symbol, untyped]]
+        # @rbs version: Integer
+        # @rbs return: void
+        def change(uri:, content_changes:, version:)
+          entry = @documents[uri]
+          return unless entry
+
+          changes = content_changes.map do |change|
+            range = change[:range]
+            ::Steep::Services::ContentChange.new(
+              range: range && [
+                ::Steep::Services::ContentChange::Position.new(
+                  line: range[:start][:line] + 1,
+                  column: range[:start][:character],
+                ),
+                ::Steep::Services::ContentChange::Position.new(
+                  line: range[:end][:line] + 1,
+                  column: range[:end][:character],
+                ),
+              ],
+              text: change[:text],
+            )
+          end
+
+          # Update the stored content with the last full text
+          last_change = content_changes.last
+          if last_change && !last_change[:range]
+            @documents[uri] = DocumentEntry.new(uri: uri, content: last_change[:text], version: version)
+          else
+            @documents[uri] = DocumentEntry.new(uri: uri, content: entry.content, version: version)
+          end
+
+          path = uri_to_relative_path(uri)
+          return unless path
+
+          @steep_state.push_changes(path, changes)
+        end
+
+        # @rbs uri: String
+        # @rbs return: void
+        def close(uri:)
+          @documents.delete(uri)
+        end
+
+        # @rbs uri: String
+        # @rbs return: DocumentEntry?
+        def get(uri)
+          @documents[uri]
+        end
+
+        private
+
+        # @rbs uri: String
+        # @rbs return: Pathname?
+        def uri_to_relative_path(uri)
+          path = ::Steep::PathHelper.to_pathname(uri)
+          return unless path
+
+          @steep_state.project.relative_path(path)
+        end
+      end
+    end
+  end
+end

data/lib/refined/steep/server/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Refined
+  module Steep
+    module Server
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/refined/steep/server.rb

@@ -0,0 +1,22 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "language_server-protocol"
+require "steep"
+require "json"
+
+require_relative "server/version"
+require_relative "server/message"
+require_relative "server/io"
+require_relative "server/base_server"
+require_relative "server/steep_state"
+require_relative "server/store"
+require_relative "server/lsp_server"
+
+module Refined
+  module Steep
+    module Server
+      class Error < StandardError; end
+    end
+  end
+end

data/rbs_collection.yaml

@@ -0,0 +1,19 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# You can specify local directories as sources also.
+# - type: local
+#   path: path/to/your/local/repository
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+# gems:
+#   # If you want to avoid installing rbs files for gems, you can specify them here.
+#   - name: GEM_NAME
+#     ignore: true