refined-steep-server 0.1.0

data/spec/refined/steep/server/lsp_server_spec.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+RSpec.describe Refined::Steep::Server::LspServer do
+  include_context "lsp_helpers"
+
+  describe "initialize request" do
+    it "returns server capabilities" do
+      messages = [
+        {
+          id: 1,
+          method: "initialize",
+          params: {
+            rootUri: "file://#{fixtures_dir}",
+            capabilities: {},
+          },
+        },
+      ]
+
+      server, writer = create_server(messages)
+      server.start
+      sleep 0.1
+
+      responses = parse_responses(writer)
+      init_response = responses.find { |r| r[:id] == 1 }
+
+      expect(init_response).not_to be_nil
+      result = init_response[:result]
+      capabilities = result[:capabilities]
+
+      expect(capabilities[:hoverProvider]).to be true
+      expect(capabilities[:definitionProvider]).to be true
+      expect(capabilities[:implementationProvider]).to be true
+      expect(capabilities[:typeDefinitionProvider]).to be true
+      expect(capabilities[:workspaceSymbolProvider]).to be true
+      expect(capabilities[:completionProvider]).to include(:triggerCharacters)
+      expect(capabilities[:signatureHelpProvider]).to include(:triggerCharacters)
+      expect(capabilities[:textDocumentSync][:openClose]).to be true
+      expect(result[:serverInfo][:name]).to eq("refined-steep-server")
+    end
+  end
+
+  describe "textDocument/didOpen and didClose" do
+    it "tracks document lifecycle" do
+      uri = "file://#{lib_dir}/test.rb"
+      messages = init_messages([
+        {
+          method: "textDocument/didOpen",
+          params: {
+            textDocument: { uri: uri, languageId: "ruby", version: 1, text: "class Foo; end" },
+          },
+        },
+        {
+          method: "textDocument/didClose",
+          params: { textDocument: { uri: uri } },
+        },
+      ])
+
+      server, = create_server(messages)
+      server.start
+      sleep 0.2
+
+      expect(server.store&.get(uri)).to be_nil
+    end
+  end
+
+  describe "textDocument/didChange" do
+    it "applies changes through store" do
+      uri = "file://#{lib_dir}/test.rb"
+      messages = init_messages([
+        {
+          method: "textDocument/didOpen",
+          params: {
+            textDocument: { uri: uri, languageId: "ruby", version: 1, text: "class Foo; end" },
+          },
+        },
+        {
+          method: "textDocument/didChange",
+          params: {
+            textDocument: { uri: uri, version: 2 },
+            contentChanges: [{ text: "class Bar; end" }],
+          },
+        },
+      ])
+
+      server, = create_server(messages)
+      server.start
+      sleep 0.2
+
+      entry = server.store&.get(uri)
+      expect(entry).not_to be_nil
+      expect(entry.content).to eq("class Bar; end")
+      expect(entry.version).to eq(2)
+    end
+  end
+
+  describe "shutdown and exit" do
+    it "shuts down cleanly" do
+      messages = [
+        {
+          id: 1,
+          method: "initialize",
+          params: { rootUri: "file://#{fixtures_dir}", capabilities: {} },
+        },
+        { id: 2, method: "shutdown", params: {} },
+        { method: "exit" },
+      ]
+
+      server, writer = create_server(messages)
+
+      expect { server.start }.to raise_error(SystemExit) do |error|
+        expect(error.status).to eq(0)
+      end
+
+      responses = parse_responses(writer)
+      shutdown_response = responses.find { |r| r[:id] == 2 }
+      expect(shutdown_response).not_to be_nil
+      expect(shutdown_response[:result]).to be_nil
+    end
+  end
+
+  describe "Steepfile discovery" do
+    it "finds Steepfile from rootUri" do
+      messages = [
+        {
+          id: 1,
+          method: "initialize",
+          params: { rootUri: "file://#{fixtures_dir}", capabilities: {} },
+        },
+      ]
+
+      server, = create_server(messages)
+      server.start
+      sleep 0.1
+
+      expect(server.steep_state).not_to be_nil
+      expect(server.steep_state.project.targets.size).to eq(1)
+    end
+  end
+
+  context "with typed project" do
+    let(:source_code) do
+      <<~RUBY
+        class Greeter
+          attr_reader :name
+
+          def initialize(name)
+            @name = name
+          end
+
+          def greet
+            "Hello, " + name
+          end
+        end
+      RUBY
+    end
+
+    let(:rbs_content) do
+      <<~RBS
+        class Greeter
+          attr_reader name: String
+
+          def initialize: (String name) -> void
+          def greet: () -> String
+        end
+      RBS
+    end
+
+    before do
+      (lib_dir / "greeter.rb").write(source_code)
+      (sig_dir / "greeter.rbs").write(rbs_content)
+    end
+
+    def open_and_request(id:, method:, uri:, text:, request_params:)
+      init_messages([
+        {
+          method: "textDocument/didOpen",
+          params: {
+            textDocument: { uri: uri, languageId: "ruby", version: 1, text: text },
+          },
+        },
+        { id: id, method: method, params: request_params },
+      ])
+    end
+
+    describe "textDocument/completion" do
+      it "returns completion items for method calls" do
+        uri = "file://#{lib_dir}/greeter.rb"
+        completion_source = source_code.sub("\"Hello, \" + name", "self.")
+
+        messages = open_and_request(
+          id: 10,
+          method: "textDocument/completion",
+          uri: uri,
+          text: completion_source,
+          request_params: {
+            textDocument: { uri: uri },
+            position: { line: 8, character: 9 },
+            context: { triggerKind: 2, triggerCharacter: "." },
+          },
+        )
+
+        server, writer = create_server(messages)
+        server.start
+        sleep 1.0
+
+        responses = parse_responses(writer)
+        completion_response = responses.find { |r| r[:id] == 10 }
+
+        expect(completion_response).not_to be_nil
+        expect(completion_response[:error]).to be_nil
+
+        result = completion_response[:result]
+        expect(result).to include(:items)
+
+        items = result[:items]
+        labels = items.map { |item| item[:label] }
+        expect(labels).to include("name")
+        expect(labels).to include("greet")
+
+        # Completion items should include documentation with type info
+        name_item = items.find { |item| item[:label] == "name" }
+        expect(name_item[:documentation]).not_to be_nil
+        expect(name_item[:documentation][:kind]).to eq("markdown")
+
+        greet_item = items.find { |item| item[:label] == "greet" }
+        expect(greet_item[:documentation]).not_to be_nil
+      end
+
+      it "returns empty completion list when no completions available" do
+        uri = "file://#{lib_dir}/greeter.rb"
+
+        messages = open_and_request(
+          id: 10,
+          method: "textDocument/completion",
+          uri: uri,
+          text: source_code,
+          request_params: {
+            textDocument: { uri: uri },
+            position: { line: 0, character: 0 },
+            context: { triggerKind: 1 },
+          },
+        )
+
+        server, writer = create_server(messages)
+        server.start
+        sleep 1.0
+
+        responses = parse_responses(writer)
+        completion_response = responses.find { |r| r[:id] == 10 }
+
+        expect(completion_response).not_to be_nil
+        expect(completion_response[:error]).to be_nil
+
+        result = completion_response[:result]
+        expect(result).to include(:items)
+        expect(result[:items]).to be_an(Array)
+      end
+
+      it "returns completion response without error for unknown file" do
+        unknown_uri = "file://#{lib_dir}/unknown.rb"
+
+        messages = init_messages([
+          {
+            id: 10,
+            method: "textDocument/completion",
+            params: {
+              textDocument: { uri: unknown_uri },
+              position: { line: 0, character: 0 },
+              context: { triggerKind: 1 },
+            },
+          },
+        ])
+
+        server, writer = create_server(messages)
+        server.start
+        sleep 0.5
+
+        responses = parse_responses(writer)
+        completion_response = responses.find { |r| r[:id] == 10 }
+
+        expect(completion_response).not_to be_nil
+        if completion_response[:result]
+          expect(completion_response[:result][:items]).to be_an(Array)
+        else
+          expect(completion_response[:result]).to be_nil
+        end
+      end
+    end
+
+    describe "textDocument/hover" do
+      it "returns hover information for typed expressions" do
+        uri = "file://#{lib_dir}/greeter.rb"
+
+        messages = open_and_request(
+          id: 10,
+          method: "textDocument/hover",
+          uri: uri,
+          text: source_code,
+          request_params: {
+            textDocument: { uri: uri },
+            position: { line: 3, character: 10 },
+          },
+        )
+
+        server, writer = create_server(messages)
+        server.start
+        sleep 1.0
+
+        responses = parse_responses(writer)
+        hover_response = responses.find { |r| r[:id] == 10 }
+
+        expect(hover_response).not_to be_nil
+        expect(hover_response[:error]).to be_nil
+      end
+    end
+  end
+end

data/spec/refined/steep/server/message_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+RSpec.describe Refined::Steep::Server do
+  describe Refined::Steep::Server::Result do
+    it "serializes to hash with id and result" do
+      result = Refined::Steep::Server::Result.new(id: 1, response: { key: "value" })
+      expect(result.to_hash).to eq({ id: 1, result: { key: "value" } })
+    end
+
+    it "serializes nil response" do
+      result = Refined::Steep::Server::Result.new(id: 2, response: nil)
+      expect(result.to_hash).to eq({ id: 2, result: nil })
+    end
+  end
+
+  describe Refined::Steep::Server::ErrorResponse do
+    it "serializes to hash with error structure" do
+      error = Refined::Steep::Server::ErrorResponse.new(
+        id: 1,
+        code: -32600,
+        message: "Invalid Request",
+      )
+      expect(error.to_hash).to eq({
+        id: 1,
+        error: {
+          code: -32600,
+          message: "Invalid Request",
+          data: nil,
+        },
+      })
+    end
+
+    it "includes data when provided" do
+      error = Refined::Steep::Server::ErrorResponse.new(
+        id: 1,
+        code: -32600,
+        message: "Invalid Request",
+        data: { detail: "something" },
+      )
+      expect(error.to_hash[:error][:data]).to eq({ detail: "something" })
+    end
+  end
+
+  describe Refined::Steep::Server::Notification do
+    it "serializes to hash with method and params" do
+      notification = Refined::Steep::Server::Notification.window_log_message("hello")
+      hash = notification.to_hash
+      expect(hash[:method]).to eq("window/logMessage")
+      expect(hash[:params]).to include(:type, :message)
+    end
+
+    it "creates publish_diagnostics notification" do
+      notification = Refined::Steep::Server::Notification.publish_diagnostics(
+        "file:///test.rb",
+        [],
+      )
+      hash = notification.to_hash
+      expect(hash[:method]).to eq("textDocument/publishDiagnostics")
+      expect(hash[:params][:uri]).to eq("file:///test.rb")
+    end
+  end
+
+  describe Refined::Steep::Server::Request do
+    it "serializes to hash with id, method, and params" do
+      params = LanguageServer::Protocol::Interface::ShowMessageParams.new(
+        type: 1,
+        message: "test",
+      )
+      request = Refined::Steep::Server::Request.new(
+        id: 5,
+        method: "window/showMessage",
+        params: params,
+      )
+      hash = request.to_hash
+      expect(hash[:id]).to eq(5)
+      expect(hash[:method]).to eq("window/showMessage")
+      expect(hash[:params]).to include(:type, :message)
+    end
+  end
+end

data/spec/refined/steep/server/steep_state_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+RSpec.describe Refined::Steep::Server::SteepState do
+  include_context "steep_fixture"
+
+  describe "#initialize" do
+    it "loads the project from Steepfile" do
+      state = described_class.new(steepfile_path: steepfile_path)
+      expect(state.project).to be_a(::Steep::Project)
+      expect(state.project.targets.size).to eq(1)
+      expect(state.project.targets[0].name).to eq(:lib)
+    end
+
+    it "creates a TypeCheckService" do
+      state = described_class.new(steepfile_path: steepfile_path)
+      expect(state.type_check_service).to be_a(::Steep::Services::TypeCheckService)
+    end
+  end
+
+  describe "#push_changes and #flush_changes" do
+    it "buffers and flushes changes" do
+      state = described_class.new(steepfile_path: steepfile_path)
+      path = Pathname("lib/test.rb")
+      change = ::Steep::Services::ContentChange.new(text: "class Foo; end")
+
+      state.push_changes(path, [change])
+      flushed = state.flush_changes
+
+      expect(flushed.keys).to eq([path])
+      expect(flushed[path].size).to eq(1)
+      expect(flushed[path][0].text).to eq("class Foo; end")
+    end
+
+    it "clears buffer after flush" do
+      state = described_class.new(steepfile_path: steepfile_path)
+      path = Pathname("lib/test.rb")
+      change = ::Steep::Services::ContentChange.new(text: "class Foo; end")
+
+      state.push_changes(path, [change])
+      state.flush_changes
+      flushed = state.flush_changes
+
+      expect(flushed).to be_empty
+    end
+  end
+end

data/spec/refined/steep/server/store_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+RSpec.describe Refined::Steep::Server::Store do
+  include_context "steep_fixture"
+
+  let(:steep_state) { Refined::Steep::Server::SteepState.new(steepfile_path: steepfile_path) }
+  let(:store) { described_class.new(steep_state) }
+
+  describe "#open" do
+    it "stores the document" do
+      uri = "file://#{fixtures_dir}/lib/test.rb"
+      store.open(uri: uri, text: "class Foo; end", version: 1)
+
+      entry = store.get(uri)
+      expect(entry).not_to be_nil
+      expect(entry.content).to eq("class Foo; end")
+      expect(entry.version).to eq(1)
+    end
+
+    it "pushes changes to steep_state" do
+      uri = "file://#{fixtures_dir}/lib/test.rb"
+      store.open(uri: uri, text: "class Foo; end", version: 1)
+
+      changes = steep_state.flush_changes
+      expect(changes).not_to be_empty
+    end
+  end
+
+  describe "#change" do
+    it "pushes incremental changes to steep_state" do
+      uri = "file://#{fixtures_dir}/lib/test.rb"
+      store.open(uri: uri, text: "class Foo; end", version: 1)
+      steep_state.flush_changes
+
+      store.change(
+        uri: uri,
+        content_changes: [
+          {
+            range: {
+              start: { line: 0, character: 6 },
+              end: { line: 0, character: 9 },
+            },
+            text: "Bar",
+          },
+        ],
+        version: 2,
+      )
+
+      changes = steep_state.flush_changes
+      expect(changes).not_to be_empty
+      path = changes.keys.first
+      expect(changes[path].first.text).to eq("Bar")
+      expect(changes[path].first.range).not_to be_nil
+    end
+
+    it "pushes full text changes to steep_state" do
+      uri = "file://#{fixtures_dir}/lib/test.rb"
+      store.open(uri: uri, text: "class Foo; end", version: 1)
+      steep_state.flush_changes
+
+      store.change(
+        uri: uri,
+        content_changes: [{ text: "class Bar; end" }],
+        version: 2,
+      )
+
+      entry = store.get(uri)
+      expect(entry.content).to eq("class Bar; end")
+      expect(entry.version).to eq(2)
+    end
+  end
+
+  describe "#close" do
+    it "removes the document" do
+      uri = "file://#{fixtures_dir}/lib/test.rb"
+      store.open(uri: uri, text: "class Foo; end", version: 1)
+      store.close(uri: uri)
+
+      expect(store.get(uri)).to be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "refined/steep/server"
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.order = :random
+end
+
+RSpec.shared_context "steep_fixture" do
+  let(:fixtures_dir) { Pathname(File.expand_path("../fixtures", __dir__)) }
+  let(:steepfile_path) { fixtures_dir / "Steepfile" }
+  let(:lib_dir) { fixtures_dir / "lib" }
+  let(:sig_dir) { fixtures_dir / "sig" }
+
+  before do
+    FileUtils.mkdir_p(lib_dir)
+    FileUtils.mkdir_p(sig_dir)
+    steepfile_path.write(<<~RUBY)
+      target :lib do
+        check "lib"
+        signature "sig"
+      end
+    RUBY
+  end
+
+  after do
+    FileUtils.rm_rf(fixtures_dir)
+  end
+end
+
+RSpec.shared_context "lsp_helpers" do
+  include_context "steep_fixture"
+
+  let(:logger) { Refined::Steep::Server::BaseServer.create_default_logger(level: Logger::WARN, io: StringIO.new) }
+
+  def encode_message(hash)
+    json = JSON.generate(hash)
+    "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
+  end
+
+  def create_server(messages)
+    raw = messages.map { |m| encode_message(m) }.join
+    reader = StringIO.new(raw)
+    writer = StringIO.new
+
+    server = Refined::Steep::Server::LspServer.new(reader: reader, writer: writer, logger: logger)
+    [server, writer]
+  end
+
+  def parse_responses(writer)
+    output = writer.string
+    responses = []
+    scanner = StringIO.new(output)
+    while (headers = scanner.gets("\r\n\r\n"))
+      content_length = headers[/Content-Length: (\d+)/i, 1]&.to_i
+      next unless content_length
+
+      raw = scanner.read(content_length)
+      next unless raw
+
+      responses << JSON.parse(raw, symbolize_names: true)
+    end
+    responses
+  end
+
+  def init_messages(extras = [])
+    [
+      {
+        id: 1,
+        method: "initialize",
+        params: { rootUri: "file://#{fixtures_dir}", capabilities: {} },
+      },
+      { method: "initialized", params: {} },
+      *extras,
+    ]
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: refined-steep-server
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- joker1007
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: steep
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: language_server-protocol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+description: Language server implementation that provides Steep-equivalent type checking
+  features using ruby-lsp's single-process multi-threaded architecture
+email:
+- kakyoin.hierophant@gmail.com
+executables:
+- refined-steep-server
+extensions: []
+extra_rdoc_files: []
+files:
+- ".claude/commands/add-stub.md"
+- ".claude/commands/check.md"
+- ".github/workflows/ci.yml"
+- ".rspec"
+- CLAUDE.md
+- README.md
+- Rakefile
+- Steepfile
+- exe/refined-steep-server
+- lib/refined/steep/server.rb
+- lib/refined/steep/server/base_server.rb
+- lib/refined/steep/server/io.rb
+- lib/refined/steep/server/lsp_server.rb
+- lib/refined/steep/server/message.rb
+- lib/refined/steep/server/steep_state.rb
+- lib/refined/steep/server/store.rb
+- lib/refined/steep/server/version.rb
+- rbs_collection.yaml
+- sig/external/steep.rbs
+- sig/refined/steep/server.rbs
+- spec/refined/steep/server/base_server_spec.rb
+- spec/refined/steep/server/io_spec.rb
+- spec/refined/steep/server/lsp_server_spec.rb
+- spec/refined/steep/server/message_spec.rb
+- spec/refined/steep/server/steep_state_spec.rb
+- spec/refined/steep/server/store_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/joker1007/refined-steep-server
+licenses: []
+metadata:
+  homepage_uri: https://github.com/joker1007/refined-steep-server
+  source_code_uri: https://github.com/joker1007/refined-steep-server
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: A language server using Steep as a library with ruby-lsp architecture
+test_files: []