kanayago 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2ec99120dc51fa4605b265aa47d5474d7f9a3540e3d09e10f782eebebcced6f
-  data.tar.gz: 0c836dc8b6390755edbbe0a42fe5fc936bb788961c313c75e0c7c559cd61afc2
+  metadata.gz: 70152c7596a4203fee587c54a35ab9c959346881525adceaff93a00ebc13c8c8
+  data.tar.gz: c2da754698c773ed1d0e23fa3566c96feb204cf63123d3c561c750ef8c0db75c
 SHA512:
-  metadata.gz: cd996926d976b0dc9e48f6ee8478d65dd0c02a48dfc81e1754a087a92e10c79f6ec174c34da2eade27c563c04b4c70a638e2ed501c0002c4d5b2e8988d8c1e48
-  data.tar.gz: f8bc6647c4daed8b6ed823c7f6e2dcb65646a735f9a9a5c6818e1a514463eb38c1bcf014d106621bbd81bf6de4f71e1b5385639dd4eeb64e727281d0d5ad1a68
+  metadata.gz: 497bfbc8020190f5c356728c6f36769978a93a288be653fc929269b619ac1b3e0575b5d3cfeda9f9fe750c0b59edd4a21e86c9ffe1b89fca1847f55b38e28ec4
+  data.tar.gz: 368c35402d3575d61c81893b834866d96ccd8c99162193ae212636984b049f8ab443e6a639a0e9d160a58083514477babf0d334f4f08a134569f531343eae1fc

data/CHANGELOG.md

@@ -7,6 +7,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.0]
+
+### Added
+- Add official editor plugins for LSP integration
+  - VSCode extension: `vscode-kanayago` available on Visual Studio Marketplace
+  - coc.nvim extension: `coc-kanayago` installable via `:CocInstall coc-kanayago`
+  - Add screenshots and integration guides to README for both plugins
+- Add Emacs integration guide to README
+  - Add lsp-mode configuration example for `init.el`
+  - Document how to register Kanayago LSP server and enable it for Ruby files
+- Add Helix editor integration guide to README
+  - Add configuration example for `~/.config/helix/languages.toml`
+  - Document how to use Kanayago LSP with Helix editor
+- Add Zed editor integration guide to README
+  - Add official Zed extension `zed-kanayago` available on Zed Extensions marketplace
+  - Document how to install and use Kanayago LSP with Zed editor
+  - Add manual installation guide for development purposes
+- Add `script_lines` support to parser for accurate line information
+  - Enable `rb_ruby_parser_set_script_lines()` in parser to capture source code lines
+  - Add `script_lines` attribute to `ParseResult` class
+  - Expose script_lines array containing each line of parsed source code
+  - Use script_lines for accurate character range calculation in LSP diagnostics
+
+### Fixed
+- Fix LSP diagnostics to report accurate error line numbers
+  - Update error message pattern matching to support both `main:LINE:` and `(eval):LINE:` formats
+  - Remove incorrect `-1` offset that was causing errors to be reported one line above the actual error location
+  - Parser already returns 0-based line numbers, matching LSP protocol requirements
+  - Clean up error messages by removing redundant `main:LINE:` prefix from diagnostic messages
+  - Add comprehensive test cases for error line detection in multi-line source code
+- Fix LSP diagnostics not showing underlines in VSCode
+  - Use `script_lines` to calculate accurate line length for diagnostic range end position
+  - Set proper character range (`end.character`) to display red squiggly lines on entire error line
+  - Previously, `start` and `end` positions were identical (both at character 0), preventing underlines from appearing
+
 ## [0.5.0]
 
 ### Added

data/README.md

@@ -31,7 +31,7 @@ Finally, build `Kanayago` gem  and install it.
 
 ```console
 bundle exec rake build
-gem install pkg/kanayago-0.5.0.gem
+gem install pkg/kanayago-0.6.0.gem
 ```
 
 ## Usage
@@ -47,25 +47,62 @@ $ kanayago --lsp
 
 This starts an LSP server that communicates via stdin/stdout. You can integrate it with LSP-compliant editors like VSCode, Vim, Emacs, etc.
 
-#### VSCode Integration Example
+#### VSCode Integration
 
-Create or modify `.vscode/settings.json`:
+Install the official VSCode extension from the marketplace:
+
+1. Open VSCode and search for "VSCode Kanayago" in the Extensions view
+2. Click Install
+
+**Configuration:**
 
 ```json
 {
-  "ruby.lsp.enabled": false,
-  "ruby.languageServer": "kanayago-lsp",
-  "ruby.languageServerPath": "kanayago",
-  "ruby.languageServerArgs": ["--lsp"]
+  "kanayago.serverPath": "kanayago",
+  "kanayago.trace.server": "off"
 }
 ```
 
 Now VSCode will show syntax errors in real-time as you type Ruby code.
 
-#### Vim/Neovim with coc.nvim Integration Example
+![VSCode Kanayago in action](images/vscode-kanayago-demo.png)
+
+#### Vim/Neovim with coc.nvim Integration
+
+##### Using coc-kanayago Extension (Recommended)
+
+Install the official coc.nvim extension:
+
+```vim
+:CocInstall coc-kanayago
+```
+
+**Configuration:**
 
 Add the following to your `coc-settings.json` (`:CocConfig` in Vim):
 
+```json
+{
+  "coc-kanayago.enable": true,
+  "coc-kanayago.command": "kanayago"
+}
+```
+
+**Diagnostic Navigation:**
+
+The extension supports standard coc.nvim diagnostic keybindings:
+- Next diagnostic: `<space>dn`
+- Previous diagnostic: `<space>dp`
+- Show diagnostic info: `<space>di`
+
+See [coc-kanayago](https://github.com/S-H-GAMELINKS/coc-kanayago) for more details.
+
+![coc-kanayago in action](images/coc-kanayago-demo.png)
+
+##### Manual LSP Configuration
+
+Alternatively, you can configure the LSP server manually in your `coc-settings.json`:
+
 ```json
 {
   "languageserver": {
@@ -81,6 +118,80 @@ Add the following to your `coc-settings.json` (`:CocConfig` in Vim):
 
 Now Vim/Neovim with coc.nvim will show syntax errors in real-time as you edit Ruby files.
 
+#### Emacs Integration
+
+If you're using Emacs with lsp-mode, add the following configuration to your `init.el`:
+
+```elisp
+(require 'lsp-mode)
+
+;; Register Kanayago LSP server
+(lsp-register-client
+ (make-lsp-client
+  :new-connection (lsp-stdio-connection '("kanayago" "--lsp"))
+  :major-modes '(ruby-mode enh-ruby-mode)
+  :server-id 'kanayago-lsp
+  :priority 10))
+
+;; Enable lsp-mode for Ruby files
+(add-hook 'ruby-mode-hook #'lsp-deferred)
+```
+
+Kanayago will automatically check your Ruby code for syntax errors and display diagnostics in real-time.
+
+#### Helix Integration
+
+Add the following configuration to your `~/.config/helix/languages.toml`:
+
+```toml
+[[language]]
+name = "ruby"
+language-servers = ["kanayago"]
+
+[language-server.kanayago]
+command = "kanayago"
+args = ["--lsp"]
+```
+
+If you already have a Ruby language configuration, you can add `"kanayago"` to your existing language-servers array:
+
+```toml
+[[language]]
+name = "ruby"
+language-servers = ["kanayago", "solargraph"]  # Use alongside other LSPs
+
+[language-server.kanayago]
+command = "kanayago"
+args = ["--lsp"]
+```
+
+Now Helix will show syntax errors in real-time as you edit Ruby files.
+
+#### Zed Integration
+
+Install the official Zed extension from the marketplace:
+
+1. Open Zed and go to Extensions (`cmd/ctrl + shift + x`)
+2. Search for "Kanayago"
+3. Click Install
+
+**Manual Installation:**
+
+If you prefer to install manually or for development purposes:
+
+```bash
+git clone https://github.com/S-H-GAMELINKS/zed-kanayago.git
+cd zed-kanayago
+```
+
+Then follow the [Zed extension development guide](https://zed.dev/docs/extensions) for installation.
+
+**Requirements:**
+- Kanayago must be installed and available in your PATH
+- Zed will automatically start the LSP server when opening Ruby files
+
+See [zed-kanayago](https://github.com/S-H-GAMELINKS/zed-kanayago) for more details.
+
 ### Command Line Interface
 
 Kanayago provides a CLI for syntax checking:

data/ext/kanayago/kanayago.c

@@ -520,6 +520,9 @@ kanayago_parse(VALUE self, VALUE source)
     // Enable error tolerant parser
     rb_ruby_parser_error_tolerant(parser_params);
 
+    // Enable script_lines to get source lines from AST
+    rb_ruby_parser_set_script_lines(parser_params);
+
     VALUE vast = rb_parser_compile_string(vparser, "main", source, 0);
 
     rb_ast_t *ast = rb_ruby_ast_data_get(vast);
@@ -528,9 +531,13 @@ kanayago_parse(VALUE self, VALUE source)
     // Get error_buffer from parser_params using accessor function
     VALUE error_buffer = rb_ruby_parser_error_buffer_get(parser_params);
 
+    // Get script_lines from AST and convert to Ruby array
+    VALUE script_lines = rb_parser_build_script_lines_from(ast->body.script_lines);
+
     VALUE result = rb_hash_new();
     rb_hash_aset(result, ID2SYM(rb_intern("ast")), ast_node);
     rb_hash_aset(result, ID2SYM(rb_intern("error")), error_buffer);
+    rb_hash_aset(result, ID2SYM(rb_intern("script_lines")), script_lines);
 
     return result;
 }

data/ext/kanayago/kanayago.h

@@ -13,6 +13,8 @@ VALUE rb_node_imaginary_literal_val(const NODE *);
 VALUE rb_node_str_string_val(const NODE *);
 VALUE rb_node_sym_string_val(const NODE *);
 VALUE rb_ruby_parser_error_buffer_get(rb_parser_t *);
+void rb_ruby_parser_set_script_lines(rb_parser_t *);
+VALUE rb_parser_build_script_lines_from(rb_parser_ary_t *);
 
 // Add extern for Kanayago
 extern const rb_data_type_t ruby_parser_data_type;

data/lib/kanayago/lsp/diagnostics.rb

@@ -14,7 +14,7 @@ module Kanayago
         if result.invalid?
           # Extract error information from SyntaxError
           error = result.error
-          diagnostic = create_diagnostic(error)
+          diagnostic = create_diagnostic(error, result.script_lines)
           diagnostics << diagnostic
         end
 
@@ -23,36 +23,41 @@ module Kanayago
 
       private
 
-      def create_diagnostic(error)
+      def create_diagnostic(error, script_lines)
         # Try to extract line and column from error message
         # SyntaxError message format: "syntax error, unexpected ..."
         # or with location: "(eval):2: syntax error, unexpected ..."
-        range = extract_range_from_error(error)
+        range = extract_range_from_error(error, script_lines)
 
         {
           range: range,
           severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
           source: 'Kanayago',
-          message: error.message
+          message: error.message.sub(/main:\d+:\s*/, '')
         }
       end
 
-      def extract_range_from_error(error)
+      def extract_range_from_error(error, script_lines)
         # Try to extract line number from error message
-        # Format: "(eval):LINE: message" or just "message"
+        # Format: "main:LINE: message" or "(eval):LINE: message" or just "message"
         message = error.message
 
-        if message =~ /\(eval\):(\d+):/
-          line = ::Regexp.last_match(1).to_i - 1 # Convert to 0-based
+        if message =~ /(?:main|\(eval\)):(\d+):/
+          line = ::Regexp.last_match(1).to_i # Already 0-based or use as-is
+
+          end_character = script_lines[line].chomp.length
+
           {
             start: { line: line, character: 0 },
-            end: { line: line, character: 0 }
+            end: { line: line, character: end_character }
           }
         else
           # Default to line 0 if we can't extract line number
+          end_character = script_lines[0].chomp.length
+
           {
             start: { line: 0, character: 0 },
-            end: { line: 0, character: 0 }
+            end: { line: 0, character: end_character }
           }
         end
       end

data/lib/kanayago/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kanayago
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/lib/kanayago.rb

@@ -15,11 +15,12 @@ require_relative 'kanayago/constant_node'
 # Parse Ruby code with Ruby's Parser(Universal Parser)
 module Kanayago
   class ParseResult
-    attr_reader :ast, :error
+    attr_reader :ast, :error, :script_lines
 
-    def initialize(ast, error)
+    def initialize(ast, error, script_lines)
       @ast = ast
       @error = error
+      @script_lines = script_lines
     end
 
     def invalid?
@@ -32,8 +33,8 @@ module Kanayago
   end
 
   def self.parse(source)
-    kanayago_parse(source) in { ast:, error: }
+    kanayago_parse(source) in { ast:, error:, script_lines: }
 
-    ParseResult.new(ast, error)
+    ParseResult.new(ast, error, script_lines)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kanayago
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - S-H-GAMELINKS
@@ -55,6 +55,8 @@ files:
 - ext/kanayago/string_node.h
 - ext/kanayago/variable_node.c
 - ext/kanayago/variable_node.h
+- images/coc-kanayago-demo.png
+- images/vscode-kanayago-demo.png
 - lib/kanayago.rb
 - lib/kanayago/call_node.rb
 - lib/kanayago/cli.rb