collie-lsp 0.1.0

data/lib/collie_lsp/protocol/initialize.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Protocol
+    # Handles initialize and initialized LSP messages
+    module Initialize
+      module_function
+
+      # Handle initialize request
+      # @param request [Hash] LSP request
+      # @param writer [Object] Response writer
+      def handle(request, writer)
+        writer.write(
+          id: request[:id],
+          result: {
+            capabilities: {
+              textDocumentSync: {
+                openClose: true,
+                change: 2, # Incremental
+                save: { includeText: true }
+              },
+              documentFormattingProvider: true,
+              codeActionProvider: true,
+              hoverProvider: true,
+              completionProvider: {
+                triggerCharacters: ['%', '$']
+              },
+              definitionProvider: true,
+              referencesProvider: true,
+              documentSymbolProvider: true,
+              renameProvider: true,
+              semanticTokensProvider: {
+                legend: {
+                  tokenTypes: Handlers::SemanticTokens::TOKEN_TYPES,
+                  tokenModifiers: Handlers::SemanticTokens::TOKEN_MODIFIERS
+                },
+                full: true
+              },
+              workspaceSymbolProvider: true,
+              foldingRangeProvider: true
+            },
+            serverInfo: {
+              name: 'collie-lsp',
+              version: CollieLsp::VERSION
+            }
+          }
+        )
+      end
+
+      # Handle initialized notification
+      # @param _request [Hash] LSP request
+      # @param _writer [Object] Response writer
+      def handle_initialized(_request, _writer)
+        # Nothing to do for initialized notification
+      end
+    end
+  end
+end

data/lib/collie_lsp/protocol/shutdown.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Protocol
+    # Handles shutdown and exit LSP messages
+    module Shutdown
+      module_function
+
+      # Handle shutdown request
+      # @param request [Hash] LSP request
+      # @param writer [Object] Response writer
+      def handle(request, writer)
+        writer.write(
+          id: request[:id],
+          result: nil
+        )
+      end
+
+      # Handle exit notification
+      def handle_exit
+        exit(0)
+      end
+    end
+  end
+end

data/lib/collie_lsp/protocol/text_document.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Protocol
+    # Handles textDocument/* LSP messages
+    module TextDocument
+      module_function
+
+      # Handle textDocument/didOpen notification
+      # @param request [Hash] LSP request
+      # @param document_store [DocumentStore] Document store
+      # @param collie [CollieWrapper] Collie wrapper
+      # @param writer [Object] Response writer
+      def handle_did_open(request, document_store, collie, writer)
+        params = request[:params]
+        uri = params[:textDocument][:uri]
+        text = params[:textDocument][:text]
+        version = params[:textDocument][:version]
+
+        document_store.open(uri, text, version)
+        publish_diagnostics(uri, text, document_store, collie, writer)
+      end
+
+      # Handle textDocument/didChange notification
+      # @param request [Hash] LSP request
+      # @param document_store [DocumentStore] Document store
+      # @param collie [CollieWrapper] Collie wrapper
+      # @param writer [Object] Response writer
+      def handle_did_change(request, document_store, collie, writer)
+        params = request[:params]
+        uri = params[:textDocument][:uri]
+        version = params[:textDocument][:version]
+
+        # For full document sync (change: 1)
+        return unless params[:contentChanges]&.first&.dig(:text)
+
+        text = params[:contentChanges].first[:text]
+        document_store.change(uri, text, version)
+        publish_diagnostics(uri, text, document_store, collie, writer)
+      end
+
+      # Handle textDocument/didSave notification
+      # @param request [Hash] LSP request
+      # @param document_store [DocumentStore] Document store
+      # @param collie [CollieWrapper] Collie wrapper
+      # @param writer [Object] Response writer
+      def handle_did_save(request, document_store, collie, writer)
+        params = request[:params]
+        uri = params[:textDocument][:uri]
+        doc = document_store.get(uri)
+
+        return unless doc
+
+        publish_diagnostics(uri, doc[:text], document_store, collie, writer)
+      end
+
+      # Handle textDocument/didClose notification
+      # @param request [Hash] LSP request
+      # @param document_store [DocumentStore] Document store
+      # @param _collie [CollieWrapper] Collie wrapper (unused)
+      # @param _writer [Object] Response writer (unused)
+      def handle_did_close(request, document_store, _collie, _writer)
+        uri = request[:params][:textDocument][:uri]
+        document_store.close(uri)
+      end
+
+      # Publish diagnostics for a document
+      # @param uri [String] Document URI
+      # @param text [String] Document text
+      # @param document_store [DocumentStore] Document store
+      # @param collie [CollieWrapper] Collie wrapper
+      # @param writer [Object] Response writer
+      def publish_diagnostics(uri, text, document_store, collie, writer)
+        filename = uri.gsub(%r{^file://}, '')
+        offenses = collie.lint(text, filename: filename)
+
+        Handlers::Diagnostics.publish(uri, offenses, document_store, writer)
+      end
+    end
+  end
+end

data/lib/collie_lsp/server.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'language_server-protocol'
+
+module CollieLsp
+  # Main LSP server implementation
+  class Server
+    # Initialize server
+    # @param input [IO] Input stream (default: stdin)
+    # @param output [IO] Output stream (default: stdout)
+    def initialize(input: $stdin, output: $stdout)
+      @reader = LanguageServer::Protocol::Transport::Io::Reader.new(input)
+      @writer = LanguageServer::Protocol::Transport::Io::Writer.new(output)
+      @document_store = DocumentStore.new
+      @collie = nil
+      @workspace_root = nil
+    end
+
+    # Start the server
+    def start
+      @reader.read do |request|
+        handle_request(request)
+      end
+    end
+
+    private
+
+    # Handle an LSP request
+    # @param request [Hash] LSP request message
+    def handle_request(request)
+      case request[:method]
+      when 'initialize'
+        handle_initialize(request)
+      when 'initialized'
+        Protocol::Initialize.handle_initialized(request, @writer)
+      when 'textDocument/didOpen'
+        Protocol::TextDocument.handle_did_open(request, @document_store, @collie, @writer)
+      when 'textDocument/didChange'
+        Protocol::TextDocument.handle_did_change(request, @document_store, @collie, @writer)
+      when 'textDocument/didSave'
+        Protocol::TextDocument.handle_did_save(request, @document_store, @collie, @writer)
+      when 'textDocument/didClose'
+        Protocol::TextDocument.handle_did_close(request, @document_store, @collie, @writer)
+      when 'textDocument/formatting'
+        Handlers::Formatting.handle(request, @document_store, @collie, @writer)
+      when 'textDocument/codeAction'
+        Handlers::CodeAction.handle(request, @document_store, @collie, @writer)
+      when 'textDocument/hover'
+        Handlers::Hover.handle(request, @document_store, @collie, @writer)
+      when 'textDocument/completion'
+        Handlers::Completion.handle(request, @document_store, @collie, @writer)
+      when 'textDocument/definition'
+        Handlers::Definition.handle(request, @document_store, @collie, @writer)
+      when 'textDocument/references'
+        Handlers::References.handle(request, @document_store, @collie, @writer)
+      when 'textDocument/documentSymbol'
+        Handlers::DocumentSymbol.handle(request, @document_store, @collie, @writer)
+      when 'textDocument/rename'
+        Handlers::Rename.handle(request, @document_store, @collie, @writer)
+      when 'textDocument/semanticTokens/full'
+        Handlers::SemanticTokens.handle(request, @document_store, @collie, @writer)
+      when 'workspace/symbol'
+        Handlers::WorkspaceSymbol.handle(request, @document_store, @collie, @writer)
+      when 'textDocument/foldingRange'
+        Handlers::FoldingRange.handle(request, @document_store, @collie, @writer)
+      when 'shutdown'
+        Protocol::Shutdown.handle(request, @writer)
+      when 'exit'
+        Protocol::Shutdown.handle_exit
+      end
+    rescue StandardError => e
+      log_error("Error handling request: #{e.message}\n#{e.backtrace.join("\n")}")
+    end
+
+    # Handle initialize request and set up workspace
+    # @param request [Hash] LSP initialize request
+    def handle_initialize(request)
+      @workspace_root = extract_workspace_root(request)
+      @collie = CollieWrapper.new(workspace_root: @workspace_root)
+      Protocol::Initialize.handle(request, @writer)
+    end
+
+    # Extract workspace root from initialize request
+    # @param request [Hash] LSP initialize request
+    # @return [String, nil] Workspace root path or nil
+    def extract_workspace_root(request)
+      params = request[:params]
+      root_uri = params[:rootUri]
+      return nil unless root_uri
+
+      root_uri.gsub(%r{^file://}, '')
+    end
+
+    # Log error message
+    # @param message [String] Error message
+    def log_error(message)
+      return unless ENV['COLLIE_LSP_LOG']
+
+      File.open(ENV.fetch('COLLIE_LSP_LOG', nil), 'a') do |f|
+        f.puts "[#{Time.now}] ERROR: #{message}"
+      end
+    end
+  end
+end

data/lib/collie_lsp/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  VERSION = '0.1.0'
+end

data/lib/collie_lsp.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'collie_lsp/version'
+require_relative 'collie_lsp/server'
+require_relative 'collie_lsp/document_store'
+require_relative 'collie_lsp/collie_wrapper'
+require_relative 'collie_lsp/protocol/initialize'
+require_relative 'collie_lsp/protocol/text_document'
+require_relative 'collie_lsp/protocol/shutdown'
+require_relative 'collie_lsp/handlers/diagnostics'
+require_relative 'collie_lsp/handlers/formatting'
+require_relative 'collie_lsp/handlers/code_action'
+require_relative 'collie_lsp/handlers/hover'
+require_relative 'collie_lsp/handlers/completion'
+require_relative 'collie_lsp/handlers/definition'
+require_relative 'collie_lsp/handlers/references'
+require_relative 'collie_lsp/handlers/document_symbol'
+require_relative 'collie_lsp/handlers/rename'
+require_relative 'collie_lsp/handlers/semantic_tokens'
+require_relative 'collie_lsp/handlers/workspace_symbol'
+require_relative 'collie_lsp/handlers/folding_range'
+
+module CollieLsp
+  class Error < StandardError; end
+end

data/vscode-extension/.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+out/
+*.vsix

data/vscode-extension/.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Run Extension",
+      "type": "extensionHost",
+      "request": "launch",
+      "args": [
+        "--extensionDevelopmentPath=${workspaceFolder}"
+      ],
+      "outFiles": [
+        "${workspaceFolder}/out/**/*.js"
+      ],
+      "preLaunchTask": "${defaultBuildTask}"
+    }
+  ]
+}

data/vscode-extension/.vscode/tasks.json

@@ -0,0 +1,14 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "npm",
+      "script": "compile",
+      "group": "build",
+      "presentation": {
+        "reveal": "silent"
+      },
+      "problemMatcher": "$tsc"
+    }
+  ]
+}

data/vscode-extension/README.md

@@ -0,0 +1,35 @@
+# Collie LSP Test Extension
+
+Test extension for developing and testing collie-lsp.
+
+## Setup
+
+```bash
+# Install dependencies
+npm install
+
+# Compile TypeScript
+npm run compile
+```
+
+## Testing
+
+1. Open this folder in VS Code
+2. Press F5 to launch Extension Development Host
+3. Create a test .y file
+4. Verify LSP features work (diagnostics, completion, etc.)
+
+## Configuration
+
+In the Extension Development Host, you can configure:
+
+```json
+{
+  "collie-lsp.serverPath": "/path/to/collie-lsp",
+  "collie-lsp.trace.server": "verbose"
+}
+```
+
+## Viewing LSP Communication
+
+Open Output panel (View > Output) and select "Collie LSP" from the dropdown.

data/vscode-extension/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "collie-lsp-test",
+  "displayName": "Collie LSP Test",
+  "description": "Test extension for collie-lsp",
+  "version": "0.0.1",
+  "engines": {
+    "vscode": "^1.75.0"
+  },
+  "categories": ["Programming Languages"],
+  "activationEvents": ["onLanguage:yacc"],
+  "main": "./out/extension.js",
+  "contributes": {
+    "languages": [{
+      "id": "yacc",
+      "extensions": [".y"],
+      "aliases": ["Yacc", "yacc"]
+    }],
+    "configuration": {
+      "type": "object",
+      "title": "Collie LSP",
+      "properties": {
+        "collie-lsp.serverPath": {
+          "type": "string",
+          "default": "collie-lsp",
+          "description": "Path to collie-lsp executable"
+        },
+        "collie-lsp.trace.server": {
+          "type": "string",
+          "enum": ["off", "messages", "verbose"],
+          "default": "verbose",
+          "description": "Traces the communication between VS Code and the language server"
+        }
+      }
+    }
+  },
+  "scripts": {
+    "vscode:prepublish": "npm run compile",
+    "compile": "tsc -p ./",
+    "watch": "tsc -watch -p ./"
+  },
+  "dependencies": {
+    "vscode-languageclient": "^9.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/vscode": "^1.75.0",
+    "typescript": "^5.0.0"
+  }
+}

data/vscode-extension/src/extension.ts

@@ -0,0 +1,48 @@
+import * as path from 'path';
+import { workspace, ExtensionContext } from 'vscode';
+import {
+  LanguageClient,
+  LanguageClientOptions,
+  ServerOptions,
+  TransportKind
+} from 'vscode-languageclient/node';
+
+let client: LanguageClient;
+
+export function activate(context: ExtensionContext) {
+  // Get server path from configuration
+  const config = workspace.getConfiguration('collie-lsp');
+  const serverPath = config.get<string>('serverPath') || 'collie-lsp';
+
+  // Server options
+  const serverOptions: ServerOptions = {
+    command: serverPath,
+    args: ['--stdio'],
+    transport: TransportKind.stdio
+  };
+
+  // Client options
+  const clientOptions: LanguageClientOptions = {
+    documentSelector: [{ scheme: 'file', language: 'yacc' }],
+    synchronize: {
+      fileEvents: workspace.createFileSystemWatcher('**/.y')
+    }
+  };
+
+  // Create and start the client
+  client = new LanguageClient(
+    'collie-lsp',
+    'Collie LSP',
+    serverOptions,
+    clientOptions
+  );
+
+  client.start();
+}
+
+export function deactivate(): Thenable<void> | undefined {
+  if (!client) {
+    return undefined;
+  }
+  return client.stop();
+}

data/vscode-extension/test-grammar.y

@@ -0,0 +1,42 @@
+%{
+/* Test grammar file for collie-lsp */
+#include <stdio.h>
+%}
+
+%token NUMBER
+%token IDENTIFIER
+%token PLUS MINUS
+%token TIMES DIVIDE
+
+%left PLUS MINUS
+%left TIMES DIVIDE
+
+%%
+
+program
+    : expression
+    ;
+
+expression
+    : expression PLUS term
+    | expression MINUS term
+    | term
+    ;
+
+term
+    : term TIMES factor
+    | term DIVIDE factor
+    | factor
+    ;
+
+factor
+    : NUMBER
+    | IDENTIFIER
+    | '(' expression ')'
+    ;
+
+%%
+
+int main() {
+    return 0;
+}

data/vscode-extension/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "ES2020",
+    "outDir": "out",
+    "lib": ["ES2020"],
+    "sourceMap": true,
+    "rootDir": "src",
+    "strict": true
+  },
+  "exclude": ["node_modules", ".vscode-test"]
+}

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: collie-lsp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: language_server-protocol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.17.0
+description: collie-lsp provides real-time linting, formatting, and code intelligence
+  features for .y grammar files in any LSP-compatible editor
+email:
+- t.yudai92@gmail.com
+executables:
+- collie-lsp
+extensions: []
+extra_rdoc_files: []
+files:
+- ".collie.yml.example"
+- ".rspec"
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- collie-lsp.gemspec
+- exe/collie-lsp
+- lib/collie_lsp.rb
+- lib/collie_lsp/collie_wrapper.rb
+- lib/collie_lsp/document_store.rb
+- lib/collie_lsp/handlers/code_action.rb
+- lib/collie_lsp/handlers/completion.rb
+- lib/collie_lsp/handlers/definition.rb
+- lib/collie_lsp/handlers/diagnostics.rb
+- lib/collie_lsp/handlers/document_symbol.rb
+- lib/collie_lsp/handlers/folding_range.rb
+- lib/collie_lsp/handlers/formatting.rb
+- lib/collie_lsp/handlers/hover.rb
+- lib/collie_lsp/handlers/references.rb
+- lib/collie_lsp/handlers/rename.rb
+- lib/collie_lsp/handlers/semantic_tokens.rb
+- lib/collie_lsp/handlers/workspace_symbol.rb
+- lib/collie_lsp/protocol/initialize.rb
+- lib/collie_lsp/protocol/shutdown.rb
+- lib/collie_lsp/protocol/text_document.rb
+- lib/collie_lsp/server.rb
+- lib/collie_lsp/version.rb
+- vscode-extension/.gitignore
+- vscode-extension/.vscode/launch.json
+- vscode-extension/.vscode/tasks.json
+- vscode-extension/README.md
+- vscode-extension/package.json
+- vscode-extension/src/extension.ts
+- vscode-extension/test-grammar.y
+- vscode-extension/tsconfig.json
+homepage: https://github.com/ydah/collie-lsp
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/collie-lsp
+  source_code_uri: https://github.com/ydah/collie-lsp
+  changelog_uri: https://github.com/ydah/collie-lsp/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/ydah/collie-lsp/issues
+  documentation_uri: https://github.com/ydah/collie-lsp/blob/main/README.md
+  rubygems_mfa_required: 'true'
+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: 3.6.9
+specification_version: 4
+summary: Language Server Protocol implementation for Lrama Style BNF grammar files
+test_files: []