feat: each handler for each language

Author: shiqimei

crates/codeindex/src/handlers.rs

@@ -0,0 +1,42 @@
+use std::collections::HashMap;
+
+use tree_sitter::TreeCursor;
+
+// Handler for JavaScript function_declaration
+fn handle_js_function(cursor: &mut TreeCursor, source_code: &str) -> String {
+    let mut function_signature = String::new();
+    if cursor.goto_first_child() {
+        loop {
+            let node = cursor.node();
+            match node.kind() {
+                "identifier" => {
+                    let start_byte = node.start_byte();
+                    let end_byte = node.end_byte();
+                    let child_name = &source_code[start_byte..end_byte];
+                    function_signature.push_str(&format!("function {}", child_name));
+                }
+                "formal_parameters" => {
+                    let start_byte = node.start_byte();
+                    let end_byte = node.end_byte();
+                    let parameters = &source_code[start_byte..end_byte];
+                    function_signature.push_str(&format!("{}", parameters));
+                }
+                // JavaScript doesn't have explicit return types, so we don't handle that here
+                _ => {}
+            }
+
+            if !cursor.goto_next_sibling() {
+                break;
+            }
+        }
+        cursor.goto_parent();
+    }
+    function_signature
+}
+
+pub fn get_handlers() -> HashMap<&'static str, fn(&mut TreeCursor, &str) -> String> {
+    let mut handlers: HashMap<&str, fn(&mut TreeCursor, &str) -> String> = HashMap::new();
+    handlers.insert("function_declaration", handle_js_function);
+    // Insert more handlers as needed
+    handlers
+}

crates/codeindex/src/handlers/javascript.rs

@@ -0,0 +1,18 @@
+mod javascript;
+mod python;
+mod rust;
+mod typescript;
+
+use std::collections::HashMap;
+
+use tree_sitter::TreeCursor;
+
+pub fn get_handlers(extension: &str) -> HashMap<&'static str, fn(&mut TreeCursor, &str) -> String> {
+    match extension {
+        "js" | "jsx" => javascript::get_handlers(),
+        "ts" | "tsx" => typescript::get_handlers(),
+        "rs" => rust::get_handlers(),
+        "py" => python::get_handlers(),
+        _ => HashMap::new(),
+    }
+}

crates/codeindex/src/handlers/mod.rs

@@ -0,0 +1,66 @@
+use std::collections::HashMap;
+
+use tree_sitter::TreeCursor;
+
+// Handler for Python function_definition
+fn handle_py_function(cursor: &mut TreeCursor, source_code: &str) -> String {
+    let mut function_signature = String::new();
+    if cursor.goto_first_child() {
+        loop {
+            let node = cursor.node();
+            match node.kind() {
+                "identifier" => {
+                    let start_byte = node.start_byte();
+                    let end_byte = node.end_byte();
+                    let child_name = &source_code[start_byte..end_byte];
+                    function_signature.push_str(&format!("def {}", child_name));
+                }
+                "parameters" => {
+                    let start_byte = node.start_byte();
+                    let end_byte = node.end_byte();
+                    let parameters = &source_code[start_byte..end_byte];
+                    function_signature.push_str(&format!("{}", parameters));
+                }
+                // Python doesn't have explicit return types, so we don't handle that here
+                _ => {}
+            }
+
+            if !cursor.goto_next_sibling() {
+                break;
+            }
+        }
+        cursor.goto_parent();
+    }
+    function_signature
+}
+
+// Handler for Python class_definition
+fn handle_py_class(cursor: &mut TreeCursor, source_code: &str) -> String {
+    let mut class_signature = String::new();
+    if cursor.goto_first_child() {
+        loop {
+            let node = cursor.node();
+            if node.kind() == "identifier" {
+                let start_byte = node.start_byte();
+                let end_byte = node.end_byte();
+                let child_name = &source_code[start_byte..end_byte];
+                class_signature.push_str(&format!("class {}:", child_name));
+            }
+            // You may want to handle fields, methods, etc. here...
+
+            if !cursor.goto_next_sibling() {
+                break;
+            }
+        }
+        cursor.goto_parent();
+    }
+    class_signature
+}
+
+pub fn get_handlers() -> HashMap<&'static str, fn(&mut TreeCursor, &str) -> String> {
+    let mut handlers: HashMap<&str, fn(&mut TreeCursor, &str) -> String> = HashMap::new();
+    handlers.insert("function_definition", handle_py_function);
+    handlers.insert("class_definition", handle_py_class);
+    // Insert more handlers as needed
+    handlers
+}

crates/codeindex/src/handlers/python.rs

@@ -0,0 +1,72 @@
+use std::collections::HashMap;
+
+use tree_sitter::TreeCursor;
+
+// Handler for Rust function_item
+fn handle_rs_function(cursor: &mut TreeCursor, source_code: &str) -> String {
+    let mut function_signature = String::new();
+    if cursor.goto_first_child() {
+        loop {
+            let node = cursor.node();
+            match node.kind() {
+                "identifier" => {
+                    let start_byte = node.start_byte();
+                    let end_byte = node.end_byte();
+                    let child_name = &source_code[start_byte..end_byte];
+                    function_signature.push_str(&format!("fn {}", child_name));
+                }
+                "parameters" => {
+                    let start_byte = node.start_byte();
+                    let end_byte = node.end_byte();
+                    let parameters = &source_code[start_byte..end_byte];
+                    function_signature.push_str(&format!("{}", parameters));
+                }
+                "type_identifier" => {
+                    let start_byte = node.start_byte();
+                    let end_byte = node.end_byte();
+                    let return_type = &source_code[start_byte..end_byte];
+                    function_signature.push_str(&format!(" -> {}", return_type));
+                }
+                _ => {}
+            }
+
+            if !cursor.goto_next_sibling() {
+                break;
+            }
+        }
+        cursor.goto_parent();
+    }
+    function_signature
+}
+
+// Handler for Rust struct_item
+fn handle_rs_struct(cursor: &mut TreeCursor, source_code: &str) -> String {
+    let mut struct_signature = String::new();
+    if cursor.goto_first_child() {
+        loop {
+            let node = cursor.node();
+            if node.kind() == "identifier" {
+                let start_byte = node.start_byte();
+                let end_byte = node.end_byte();
+                let child_name = &source_code[start_byte..end_byte];
+                struct_signature.push_str(&format!("struct {} {{", child_name));
+            }
+            // You may want to handle fields here...
+
+            if !cursor.goto_next_sibling() {
+                break;
+            }
+        }
+        cursor.goto_parent();
+    }
+    struct_signature.push_str("}");
+    struct_signature
+}
+
+pub fn get_handlers() -> HashMap<&'static str, fn(&mut TreeCursor, &str) -> String> {
+    let mut handlers: HashMap<&str, fn(&mut TreeCursor, &str) -> String> = HashMap::new();
+    handlers.insert("function_item", handle_rs_function);
+    handlers.insert("struct_item", handle_rs_struct);
+    // Insert more handlers as needed
+    handlers
+}