feat: implement Rust support

Author: studyzy

.gitignore

@@ -54,4 +54,15 @@ Thumbs.db
 .vscode/
 
 # CodeI18n specific
-.codei18n/
+.codei18n/
+
+# Rust artifacts (for test data or sub-projects)
+target/
+debug/
+release/
+*.rs.bk
+*.rlib
+
+# C/C++ artifacts (for CGO)
+*.o
+*.a

adapters/registry.go

@@ -0,0 +1,24 @@
+package adapters
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/studyzy/codei18n/adapters/golang"
+	"github.com/studyzy/codei18n/adapters/rust"
+	"github.com/studyzy/codei18n/core"
+)
+
+// GetAdapter returns the appropriate LanguageAdapter for the given file
+func GetAdapter(filename string) (core.LanguageAdapter, error) {
+	ext := strings.ToLower(filepath.Ext(filename))
+	switch ext {
+	case ".go":
+		return golang.NewAdapter(), nil
+	case ".rs":
+		return rust.NewRustAdapter(), nil
+	default:
+		return nil, fmt.Errorf("unsupported file extension: %s", ext)
+	}
+}

adapters/rust/acceptance_test.go

@@ -0,0 +1,54 @@
+package rust
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRustAcceptance(t *testing.T) {
+	src := []byte(`
+// File header
+
+/// Function Doc
+fn main() {
+    // Inner logic
+    println!("Hello");
+}
+
+pub mod my_mod {
+    //! Module Doc
+    
+    /// Struct Doc
+    #[derive(Debug)]
+    pub struct MyStruct;
+}
+`)
+	adapter := NewRustAdapter()
+	comments, err := adapter.Parse("test.rs", src)
+	assert.NoError(t, err)
+	assert.Len(t, comments, 5, "Should extract 5 comments")
+
+	// Helper map to find comments by content
+	commentMap := make(map[string]string)
+	for _, c := range comments {
+		key := strings.TrimSpace(c.SourceText)
+		commentMap[key] = c.Symbol
+	}
+
+	// 1. File header
+	assert.Equal(t, "", commentMap["// File header"])
+
+	// 2. /// Function Doc -> Owner is fn main -> Path "main"
+	assert.Equal(t, "main", commentMap["/// Function Doc"])
+
+	// 3. // Inner logic -> Owner is block -> Parent is fn main -> Path "main"
+	assert.Equal(t, "main", commentMap["// Inner logic"])
+
+	// 4. //! Module Doc -> Owner is mod my_mod -> Path "my_mod"
+	assert.Equal(t, "my_mod", commentMap["//! Module Doc"])
+
+	// 5. /// Struct Doc -> Owner is struct MyStruct (skip attr) -> Path "my_mod::MyStruct"
+	assert.Equal(t, "my_mod::MyStruct", commentMap["/// Struct Doc"])
+}

adapters/rust/adapter.go

@@ -0,0 +1,42 @@
+package rust
+
+import (
+	"context"
+
+	sitter "github.com/smacker/go-tree-sitter"
+	"github.com/smacker/go-tree-sitter/rust"
+	"github.com/studyzy/codei18n/core/domain"
+)
+
+// RustAdapter implements the LanguageAdapter interface for Rust language.
+// It uses Tree-sitter to parse Rust source code and extract comments with their context.
+type RustAdapter struct {
+	parser *sitter.Parser
+}
+
+// NewRustAdapter creates a new instance of RustAdapter.
+// It initializes the Tree-sitter parser with the Rust grammar.
+func NewRustAdapter() *RustAdapter {
+	p := sitter.NewParser()
+	p.SetLanguage(rust.GetLanguage())
+	return &RustAdapter{parser: p}
+}
+
+// Language returns the language identifier ("rust").
+func (a *RustAdapter) Language() string {
+	return "rust"
+}
+
+// Parse parses the provided Rust source code and extracts comments.
+// It returns a list of domain.Comment structs containing comment text, position, and context symbol.
+// If src is nil, it currently expects the caller to handle file reading (TODO: implement file reading).
+func (a *RustAdapter) Parse(file string, src []byte) ([]*domain.Comment, error) {
+	// Parse the source code using Tree-sitter
+	tree, err := a.parser.ParseCtx(context.Background(), nil, src)
+	if err != nil {
+		return nil, err
+	}
+	defer tree.Close()
+
+	return a.extractComments(tree.RootNode(), src, file)
+}

adapters/rust/adapter_test.go

@@ -0,0 +1,17 @@
+package rust
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRustParser(t *testing.T) {
+	adapter := NewRustAdapter()
+	assert.Equal(t, "rust", adapter.Language())
+
+	src := []byte("fn main() { println!(\"Hello\"); }")
+	comments, err := adapter.Parse("main.rs", src)
+	assert.NoError(t, err)
+	assert.Empty(t, comments) // No comments in this source
+}

adapters/rust/context.go

@@ -0,0 +1,55 @@
+package rust
+
+import (
+	"strings"
+
+	sitter "github.com/smacker/go-tree-sitter"
+)
+
+// CommentType represents the type of Rust comment.
+type CommentType int
+
+const (
+	// NormalComment represents standard comments (// or /* */).
+	NormalComment CommentType = iota
+	// DocComment represents outer documentation comments (/// or /** */).
+	DocComment
+	// ModuleDocComment represents inner/module documentation comments (//! or /*! */).
+	ModuleDocComment
+)
+
+// IdentifyCommentType determines the type of comment based on its content prefix.
+func IdentifyCommentType(content string) CommentType {
+	if strings.HasPrefix(content, "///") || strings.HasPrefix(content, "/**") {
+		return DocComment
+	}
+	if strings.HasPrefix(content, "//!") || strings.HasPrefix(content, "/*!") {
+		return ModuleDocComment
+	}
+	return NormalComment
+}
+
+// FindOwnerNode finds the semantic owner node of the comment.
+// For DocComments, it looks for the next semantic sibling (skipping attributes).
+// For ModuleDocComments and NormalComments, it returns the parent node (representing the scope).
+func FindOwnerNode(commentNode *sitter.Node, src []byte) *sitter.Node {
+	content := commentNode.Content(src)
+	cType := IdentifyCommentType(content)
+
+	if cType == DocComment {
+		curr := commentNode.NextNamedSibling()
+		for curr != nil {
+			// Skip attributes (#[...]) to find the actual item
+			if curr.Type() == "attribute_item" {
+				curr = curr.NextNamedSibling()
+				continue
+			}
+			return curr
+		}
+		// Fallback to parent if no sibling found (orphaned doc comment)
+		return commentNode.Parent()
+	}
+
+	// ModuleDoc and NormalDoc belong to Parent scope
+	return commentNode.Parent()
+}

adapters/rust/edge_test.go

@@ -0,0 +1,51 @@
+package rust
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEdgeCases(t *testing.T) {
+	// Case 1: Comments inside string literals should NOT be extracted
+	src := []byte(`
+fn main() {
+    let s = "// This is not a comment";
+    let s2 = "/* Neither is this */";
+    // This is a comment
+}
+`)
+	adapter := NewRustAdapter()
+	comments, err := adapter.Parse("edge.rs", src)
+	assert.NoError(t, err)
+	assert.Len(t, comments, 1)
+	assert.Equal(t, "// This is a comment", comments[0].SourceText)
+}
+
+func TestMacros(t *testing.T) {
+	// Case 2: Comments inside macro invocations
+	src := []byte(`
+macro_rules! say_hello {
+    () => {
+        // Comment inside macro
+        println!("Hello");
+    };
+}
+
+fn main() {
+    say_hello!();
+}
+`)
+	adapter := NewRustAdapter()
+	comments, err := adapter.Parse("macro.rs", src)
+	assert.NoError(t, err)
+
+	// Tree-sitter usually parses macro_rules! body as token tree or specific structure
+	// Let's see if it catches the comment.
+	// Update: It depends on how 'macro_rules' is defined in grammar.
+	// If it extracts it, great. If not, it's acceptable for now (as per Spec).
+
+	if len(comments) > 0 {
+		assert.Contains(t, comments[0].SourceText, "Comment inside macro")
+	}
+}

adapters/rust/extractor.go

@@ -0,0 +1,69 @@
+package rust
+
+import (
+	"strings"
+
+	sitter "github.com/smacker/go-tree-sitter"
+	"github.com/smacker/go-tree-sitter/rust"
+	"github.com/studyzy/codei18n/core/domain"
+	"github.com/studyzy/codei18n/core/utils"
+)
+
+// extractComments processes the AST and extracts all comments matching the query.
+func (a *RustAdapter) extractComments(root *sitter.Node, src []byte, file string) ([]*domain.Comment, error) {
+	q, err := sitter.NewQuery([]byte(rustCommentQuery), rust.GetLanguage())
+	if err != nil {
+		return nil, err
+	}
+
+	qc := sitter.NewQueryCursor()
+	qc.Exec(q, root)
+	defer qc.Close() // Ensure cursor is closed
+
+	var comments []*domain.Comment
+
+	for {
+		m, ok := qc.NextMatch()
+		if !ok {
+			break
+		}
+
+		for _, c := range m.Captures {
+			node := c.Node
+			content := node.Content(src)
+
+			// Find Owner and Symbol Path
+			owner := FindOwnerNode(node, src)
+			symbolPath := ResolveSymbolPath(owner, src)
+
+			comment := &domain.Comment{
+				SourceText: content,
+				Symbol:     symbolPath,
+				File:       file,
+				Language:   "rust",
+				Range: domain.TextRange{
+					StartLine: int(node.StartPoint().Row) + 1,
+					StartCol:  int(node.StartPoint().Column) + 1,
+					EndLine:   int(node.EndPoint().Row) + 1,
+					EndCol:    int(node.EndPoint().Column) + 1,
+				},
+				Type: getDomainCommentType(content),
+			}
+			comment.ID = utils.GenerateCommentID(comment)
+			comments = append(comments, comment)
+		}
+	}
+
+	return comments, nil
+}
+
+// getDomainCommentType maps raw comment content to domain.CommentType
+func getDomainCommentType(content string) domain.CommentType {
+	if strings.HasPrefix(content, "/*") {
+		return domain.CommentTypeBlock
+	}
+	if strings.HasPrefix(content, "///") || strings.HasPrefix(content, "//!") {
+		return domain.CommentTypeDoc
+	}
+	return domain.CommentTypeLine
+}

adapters/rust/queries.go

@@ -0,0 +1,8 @@
+package rust
+
+// rustCommentQuery is the Tree-sitter query to extract comments.
+// It matches both line comments (//) and block comments (/* */).
+const rustCommentQuery = `
+(line_comment) @comment
+(block_comment) @comment
+`