tree_sitter 0.0.1

data/ext/tree_sitter/src/language.rs

@@ -0,0 +1,152 @@
+use libloading::{Library, Symbol};
+use magnus::{Error, Ruby};
+use once_cell::sync::Lazy;
+use std::collections::HashMap;
+use std::sync::RwLock;
+use tree_sitter_language::LanguageFn;
+
+// Global registry of loaded languages
+static LANGUAGES: Lazy<RwLock<HashMap<String, LoadedLanguage>>> =
+    Lazy::new(|| RwLock::new(HashMap::new()));
+
+struct LoadedLanguage {
+    language: tree_sitter::Language,
+    #[allow(dead_code)]
+    library: Library, // Keep library alive!
+}
+
+// Safety: tree_sitter::Language is thread-safe
+unsafe impl Send for LoadedLanguage {}
+unsafe impl Sync for LoadedLanguage {}
+
+/// Register a language from a shared library path
+pub fn register_language(name: String, library_path: String) -> Result<(), Error> {
+    let ruby = Ruby::get().unwrap();
+
+    // Load the shared library
+    let library = unsafe { Library::new(&library_path) }.map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to load library '{}': {}", library_path, e),
+        )
+    })?;
+
+    // The symbol name follows tree-sitter convention: tree_sitter_{language}
+    let symbol_name = format!("tree_sitter_{}", name);
+    let language_fn: Symbol<LanguageFn> =
+        unsafe { library.get(symbol_name.as_bytes()) }.map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!(
+                    "Failed to find symbol '{}' in '{}': {}",
+                    symbol_name, library_path, e
+                ),
+            )
+        })?;
+
+    let language: tree_sitter::Language = (*language_fn).into();
+
+    // Store language function in registry
+    let mut registry = LANGUAGES.write().map_err(|_| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            "Failed to acquire language registry lock",
+        )
+    })?;
+
+    registry.insert(name, LoadedLanguage { language, library });
+
+    Ok(())
+}
+
+/// Get a registered language by name
+pub fn get_language(name: String) -> Result<Language, Error> {
+    let ruby = Ruby::get().unwrap();
+
+    let registry = LANGUAGES.read().map_err(|_| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            "Failed to acquire language registry lock",
+        )
+    })?;
+
+    let loaded = registry.get(&name).ok_or_else(|| {
+        Error::new(
+            ruby.exception_arg_error(),
+            format!(
+                "Language '{}' not registered. Call TreeSitter.register_language first.",
+                name
+            ),
+        )
+    })?;
+
+    Ok(Language {
+        name: name.clone(),
+        inner: loaded.language.clone(),
+    })
+}
+
+/// List all registered language names
+pub fn list_languages() -> Result<Vec<String>, Error> {
+    let ruby = Ruby::get().unwrap();
+
+    let registry = LANGUAGES.read().map_err(|_| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            "Failed to acquire language registry lock",
+        )
+    })?;
+
+    Ok(registry.keys().cloned().collect())
+}
+
+/// Get a language from the registry (internal use).
+/// Returns the raw `tree_sitter::Language` instead of the wrapped `Language` struct,
+/// avoiding redundant wrapping when callers just need the inner type (e.g., for
+/// `parser.set_language()`). Also takes `&str` to avoid allocation.
+pub fn get_language_internal(name: &str) -> Result<tree_sitter::Language, Error> {
+    let ruby = Ruby::get().unwrap();
+
+    let registry = LANGUAGES.read().map_err(|_| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            "Failed to acquire language registry lock",
+        )
+    })?;
+
+    let loaded = registry.get(name).ok_or_else(|| {
+        Error::new(
+            ruby.exception_arg_error(),
+            format!(
+                "Language '{}' not registered. Call TreeSitter.register_language first.",
+                name
+            ),
+        )
+    })?;
+
+    Ok(loaded.language.clone())
+}
+
+#[magnus::wrap(class = "TreeSitter::Language")]
+#[derive(Clone)]
+pub struct Language {
+    pub name: String,
+    pub inner: tree_sitter::Language,
+}
+
+impl Language {
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn version(&self) -> usize {
+        self.inner.abi_version()
+    }
+
+    /// Returns the number of distinct node types (kinds) defined in this language's grammar.
+    /// Each node in a syntax tree has a kind like "function_definition" or "identifier".
+    /// Can be useful for allocation or iteration over all kinds.
+    pub fn node_kind_count(&self) -> usize {
+        self.inner.node_kind_count()
+    }
+}

data/ext/tree_sitter/src/lib.rs

@@ -0,0 +1,140 @@
+mod language;
+mod node;
+mod parser;
+mod point;
+mod query;
+mod range;
+mod tree;
+
+use magnus::{function, method, prelude::*, Error, Ruby};
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("TreeSitter")?;
+
+    module.define_singleton_method(
+        "register_language",
+        function!(language::register_language, 2),
+    )?;
+    module.define_singleton_method("language", function!(language::get_language, 1))?;
+    module.define_singleton_method("languages", function!(language::list_languages, 0))?;
+
+    let language_class = module.define_class("Language", ruby.class_object())?;
+    language_class.define_method("name", method!(language::Language::name, 0))?;
+    language_class.define_method("version", method!(language::Language::version, 0))?;
+    language_class.define_method(
+        "node_kind_count",
+        method!(language::Language::node_kind_count, 0),
+    )?;
+
+    let parser_class = module.define_class("Parser", ruby.class_object())?;
+    parser_class.define_singleton_method("new", function!(parser::Parser::new, 0))?;
+    parser_class.define_method("language=", method!(parser::Parser::set_language, 1))?;
+    parser_class.define_method("language", method!(parser::Parser::language, 0))?;
+    parser_class.define_method("parse", method!(parser::Parser::parse, -1))?;
+    parser_class.define_method("timeout_micros", method!(parser::Parser::timeout_micros, 0))?;
+    parser_class.define_method(
+        "timeout_micros=",
+        method!(parser::Parser::set_timeout_micros, 1),
+    )?;
+    parser_class.define_method("reset", method!(parser::Parser::reset, 0))?;
+
+    let tree_class = module.define_class("Tree", ruby.class_object())?;
+    tree_class.define_method("root_node", method!(tree::Tree::root_node, 0))?;
+    tree_class.define_method("source", method!(tree::Tree::source, 0))?;
+    tree_class.define_method("language", method!(tree::Tree::language, 0))?;
+
+    let node_class = module.define_class("Node", ruby.class_object())?;
+
+    // Navigation
+    node_class.define_method("parent", method!(node::Node::parent, 0))?;
+    node_class.define_method("child", method!(node::Node::child, 1))?;
+    node_class.define_method("child_count", method!(node::Node::child_count, 0))?;
+    node_class.define_method("named_child", method!(node::Node::named_child, 1))?;
+    node_class.define_method(
+        "named_child_count",
+        method!(node::Node::named_child_count, 0),
+    )?;
+    node_class.define_method(
+        "child_by_field_name",
+        method!(node::Node::child_by_field_name, 1),
+    )?;
+    node_class.define_method("children", method!(node::Node::children, 0))?;
+    node_class.define_method("named_children", method!(node::Node::named_children, 0))?;
+    node_class.define_method("next_sibling", method!(node::Node::next_sibling, 0))?;
+    node_class.define_method("prev_sibling", method!(node::Node::prev_sibling, 0))?;
+    node_class.define_method(
+        "next_named_sibling",
+        method!(node::Node::next_named_sibling, 0),
+    )?;
+    node_class.define_method(
+        "prev_named_sibling",
+        method!(node::Node::prev_named_sibling, 0),
+    )?;
+
+    // Properties
+    node_class.define_method("kind", method!(node::Node::kind, 0))?;
+    node_class.define_method("type", method!(node::Node::kind, 0))?; // Alias
+    node_class.define_method("kind_id", method!(node::Node::kind_id, 0))?;
+    node_class.define_method("named?", method!(node::Node::is_named, 0))?;
+    node_class.define_method("missing?", method!(node::Node::is_missing, 0))?;
+    node_class.define_method("extra?", method!(node::Node::is_extra, 0))?;
+    node_class.define_method("error?", method!(node::Node::is_error, 0))?;
+    node_class.define_method("has_error?", method!(node::Node::has_error, 0))?;
+    node_class.define_method("has_changes?", method!(node::Node::has_changes, 0))?;
+
+    // Position
+    node_class.define_method("start_byte", method!(node::Node::start_byte, 0))?;
+    node_class.define_method("end_byte", method!(node::Node::end_byte, 0))?;
+    node_class.define_method("start_point", method!(node::Node::start_point, 0))?;
+    node_class.define_method("end_point", method!(node::Node::end_point, 0))?;
+    node_class.define_method("range", method!(node::Node::range, 0))?;
+
+    // Text
+    node_class.define_method("text", method!(node::Node::text, 0))?;
+    node_class.define_method("to_sexp", method!(node::Node::to_sexp, 0))?;
+    node_class.define_method("to_s", method!(node::Node::to_sexp, 0))?;
+    node_class.define_method("inspect", method!(node::Node::inspect, 0))?;
+    node_class.define_method("==", method!(node::Node::eq, 1))?;
+    node_class.define_method("eql?", method!(node::Node::eq, 1))?;
+
+    let point_class = module.define_class("Point", ruby.class_object())?;
+    point_class.define_singleton_method("new", function!(point::Point::new, 2))?;
+    point_class.define_method("row", method!(point::Point::row, 0))?;
+    point_class.define_method("column", method!(point::Point::column, 0))?;
+    point_class.define_method("to_a", method!(point::Point::to_a, 0))?;
+    point_class.define_method("inspect", method!(point::Point::inspect, 0))?;
+    point_class.define_method("==", method!(point::Point::eq, 1))?;
+
+    // Range class
+    let range_class = module.define_class("Range", ruby.class_object())?;
+    range_class.define_method("start_byte", method!(range::Range::start_byte, 0))?;
+    range_class.define_method("end_byte", method!(range::Range::end_byte, 0))?;
+    range_class.define_method("start_point", method!(range::Range::start_point, 0))?;
+    range_class.define_method("end_point", method!(range::Range::end_point, 0))?;
+    range_class.define_method("size", method!(range::Range::size, 0))?;
+    range_class.define_method("inspect", method!(range::Range::inspect, 0))?;
+
+    let query_class = module.define_class("Query", ruby.class_object())?;
+    query_class.define_singleton_method("new", function!(query::Query::new, 2))?;
+    query_class.define_method("capture_names", method!(query::Query::capture_names, 0))?;
+    query_class.define_method("pattern_count", method!(query::Query::pattern_count, 0))?;
+
+    let cursor_class = module.define_class("QueryCursor", ruby.class_object())?;
+    cursor_class.define_singleton_method("new", function!(query::QueryCursor::new, 0))?;
+    cursor_class.define_method("matches", method!(query::QueryCursor::matches, 3))?;
+    cursor_class.define_method("captures", method!(query::QueryCursor::captures, 3))?;
+
+    let match_class = module.define_class("QueryMatch", ruby.class_object())?;
+    match_class.define_method(
+        "pattern_index",
+        method!(query::QueryMatch::pattern_index, 0),
+    )?;
+    match_class.define_method("captures", method!(query::QueryMatch::captures, 0))?;
+
+    let capture_class = module.define_class("QueryCapture", ruby.class_object())?;
+    capture_class.define_method("name", method!(query::QueryCapture::name, 0))?;
+    capture_class.define_method("node", method!(query::QueryCapture::node, 0))?;
+
+    Ok(())
+}

data/ext/tree_sitter/src/node.rs

@@ -0,0 +1,248 @@
+use crate::point::Point;
+use crate::range::Range;
+use magnus::{RArray, Ruby};
+use std::sync::Arc;
+
+/// Node wrapper that stores both the node data and a reference to the tree
+/// This allows child navigation while keeping the tree alive
+#[magnus::wrap(class = "TreeSitter::Node")]
+#[derive(Clone)]
+pub struct Node {
+    // Store the tree to keep nodes valid (public for query.rs)
+    pub tree: Arc<tree_sitter::Tree>,
+
+    // Source text for text extraction (public for query.rs)
+    pub source: Arc<String>,
+
+    // Node identification via byte range (used to relocate node in tree)
+    start_byte: usize,
+    end_byte: usize,
+
+    // Cached properties
+    kind: String,
+    kind_id: u16,
+    is_named: bool,
+    is_missing: bool,
+    is_extra: bool,
+    is_error: bool,
+    has_error: bool,
+    has_changes: bool,
+    start_point: Point,
+    end_point: Point,
+    child_count: usize,
+    named_child_count: usize,
+    sexp: String,
+}
+
+impl Node {
+    pub fn new(ts_node: tree_sitter::Node, source: Arc<String>, tree: Arc<tree_sitter::Tree>) -> Self {
+        Self {
+            tree,
+            source,
+            start_byte: ts_node.start_byte(),
+            end_byte: ts_node.end_byte(),
+            kind: ts_node.kind().to_string(),
+            kind_id: ts_node.kind_id(),
+            is_named: ts_node.is_named(),
+            is_missing: ts_node.is_missing(),
+            is_extra: ts_node.is_extra(),
+            is_error: ts_node.is_error(),
+            has_error: ts_node.has_error(),
+            has_changes: ts_node.has_changes(),
+            start_point: Point::from_ts(ts_node.start_position()),
+            end_point: Point::from_ts(ts_node.end_position()),
+            child_count: ts_node.child_count(),
+            named_child_count: ts_node.named_child_count(),
+            sexp: ts_node.to_sexp(),
+        }
+    }
+
+    /// Relocate the tree-sitter node from the stored tree
+    fn get_ts_node(&self) -> Option<tree_sitter::Node<'_>> {
+        let root = self.tree.root_node();
+        root.descendant_for_byte_range(self.start_byte, self.end_byte)
+    }
+
+    /// Public method for query.rs to access the tree-sitter node
+    pub fn get_ts_node_pub(&self) -> Option<tree_sitter::Node<'_>> {
+        let root = self.tree.root_node();
+        root.descendant_for_byte_range(self.start_byte, self.end_byte)
+    }
+
+    // Navigation methods
+
+    pub fn parent(&self) -> Option<Node> {
+        let ts_node = self.get_ts_node()?;
+        ts_node
+            .parent()
+            .map(|n| Node::new(n, self.source.clone(), self.tree.clone()))
+    }
+
+    pub fn child(&self, index: usize) -> Option<Node> {
+        let ts_node = self.get_ts_node()?;
+        ts_node
+            .child(index)
+            .map(|n| Node::new(n, self.source.clone(), self.tree.clone()))
+    }
+
+    pub fn child_count(&self) -> usize {
+        self.child_count
+    }
+
+    pub fn named_child(&self, index: usize) -> Option<Node> {
+        let ts_node = self.get_ts_node()?;
+        ts_node
+            .named_child(index)
+            .map(|n| Node::new(n, self.source.clone(), self.tree.clone()))
+    }
+
+    pub fn named_child_count(&self) -> usize {
+        self.named_child_count
+    }
+
+    pub fn child_by_field_name(&self, name: String) -> Option<Node> {
+        let ts_node = self.get_ts_node()?;
+        ts_node
+            .child_by_field_name(&name)
+            .map(|n| Node::new(n, self.source.clone(), self.tree.clone()))
+    }
+
+    pub fn children(&self) -> RArray {
+        let ruby = Ruby::get().unwrap();
+        let array = ruby.ary_new();
+        let Some(ts_node) = self.get_ts_node() else {
+            return array;
+        };
+        let mut cursor = ts_node.walk();
+        for n in ts_node.children(&mut cursor) {
+            let _ = array.push(Node::new(n, self.source.clone(), self.tree.clone()));
+        }
+        array
+    }
+
+    pub fn named_children(&self) -> RArray {
+        let ruby = Ruby::get().unwrap();
+        let array = ruby.ary_new();
+        let Some(ts_node) = self.get_ts_node() else {
+            return array;
+        };
+        let mut cursor = ts_node.walk();
+        for n in ts_node.named_children(&mut cursor) {
+            let _ = array.push(Node::new(n, self.source.clone(), self.tree.clone()));
+        }
+        array
+    }
+
+    pub fn next_sibling(&self) -> Option<Node> {
+        let ts_node = self.get_ts_node()?;
+        ts_node
+            .next_sibling()
+            .map(|n| Node::new(n, self.source.clone(), self.tree.clone()))
+    }
+
+    pub fn prev_sibling(&self) -> Option<Node> {
+        let ts_node = self.get_ts_node()?;
+        ts_node
+            .prev_sibling()
+            .map(|n| Node::new(n, self.source.clone(), self.tree.clone()))
+    }
+
+    pub fn next_named_sibling(&self) -> Option<Node> {
+        let ts_node = self.get_ts_node()?;
+        ts_node
+            .next_named_sibling()
+            .map(|n| Node::new(n, self.source.clone(), self.tree.clone()))
+    }
+
+    pub fn prev_named_sibling(&self) -> Option<Node> {
+        let ts_node = self.get_ts_node()?;
+        ts_node
+            .prev_named_sibling()
+            .map(|n| Node::new(n, self.source.clone(), self.tree.clone()))
+    }
+
+    // Properties
+    pub fn kind(&self) -> &str {
+        &self.kind
+    }
+
+    pub fn kind_id(&self) -> u16 {
+        self.kind_id
+    }
+
+    pub fn is_named(&self) -> bool {
+        self.is_named
+    }
+
+    pub fn is_missing(&self) -> bool {
+        self.is_missing
+    }
+
+    pub fn is_extra(&self) -> bool {
+        self.is_extra
+    }
+
+    pub fn is_error(&self) -> bool {
+        self.is_error
+    }
+
+    pub fn has_error(&self) -> bool {
+        self.has_error
+    }
+
+    pub fn has_changes(&self) -> bool {
+        self.has_changes
+    }
+
+    // Position
+    pub fn start_byte(&self) -> usize {
+        self.start_byte
+    }
+
+    pub fn end_byte(&self) -> usize {
+        self.end_byte
+    }
+
+    pub fn start_point(&self) -> Point {
+        self.start_point.clone()
+    }
+
+    pub fn end_point(&self) -> Point {
+        self.end_point.clone()
+    }
+
+    pub fn range(&self) -> Range {
+        Range::new(
+            self.start_byte,
+            self.end_byte,
+            self.start_point.clone(),
+            self.end_point.clone(),
+        )
+    }
+
+    // Text
+    pub fn text(&self) -> &str {
+        if self.end_byte <= self.source.len() {
+            &self.source[self.start_byte..self.end_byte]
+        } else {
+            ""
+        }
+    }
+
+    pub fn to_sexp(&self) -> &str {
+        &self.sexp
+    }
+
+    pub fn inspect(&self) -> String {
+        format!(
+            "#<TreeSitter::Node kind={:?} start_byte={} end_byte={}>",
+            self.kind, self.start_byte, self.end_byte
+        )
+    }
+
+    pub fn eq(&self, other: &Node) -> bool {
+        self.start_byte == other.start_byte
+            && self.end_byte == other.end_byte
+            && self.kind == other.kind
+    }
+}

data/ext/tree_sitter/src/parser.rs

@@ -0,0 +1,126 @@
+use crate::language::{get_language_internal, Language};
+use crate::tree::Tree;
+use magnus::{prelude::*, Error, RString, Ruby, TryConvert, Value};
+use std::cell::RefCell;
+use std::time::Instant;
+
+#[magnus::wrap(class = "TreeSitter::Parser")]
+pub struct Parser {
+    inner: RefCell<tree_sitter::Parser>,
+    language_name: RefCell<Option<String>>,
+    timeout_micros: RefCell<u64>,
+}
+
+impl Parser {
+    pub fn new() -> Result<Self, Error> {
+        let parser = tree_sitter::Parser::new();
+        Ok(Self {
+            inner: RefCell::new(parser),
+            language_name: RefCell::new(None),
+            timeout_micros: RefCell::new(0),
+        })
+    }
+
+    pub fn set_language(&self, lang: Value) -> Result<(), Error> {
+        let name: String = if RString::from_value(lang).is_some() {
+            <String as TryConvert>::try_convert(lang)?
+        } else {
+            // Assume it's a Language object?
+            let language: &Language = <&Language as TryConvert>::try_convert(lang)?;
+            language.name.clone()
+        };
+
+        let ts_language = get_language_internal(&name)?;
+
+        let ruby = Ruby::get().unwrap();
+        let mut parser = self.inner.borrow_mut();
+        parser.set_language(&ts_language).map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to set language: {}", e),
+            )
+        })?;
+
+        *self.language_name.borrow_mut() = Some(name);
+        Ok(())
+    }
+
+    pub fn language(&self) -> Result<Option<Language>, Error> {
+        let name = self.language_name.borrow();
+        match &*name {
+            Some(n) => {
+                let ts_lang = get_language_internal(n)?;
+                Ok(Some(Language {
+                    name: n.clone(),
+                    inner: ts_lang,
+                }))
+            }
+            None => Ok(None),
+        }
+    }
+
+    pub fn parse(&self, args: &[Value]) -> Result<Option<Tree>, Error> {
+        let ruby = Ruby::get().unwrap();
+
+        if args.is_empty() {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "wrong number of arguments",
+            ));
+        }
+
+        let source: String = <String as TryConvert>::try_convert(args[0])?;
+        let old_tree: Option<&Tree> = if args.len() > 1 && !args[1].is_nil() {
+            Some(<&Tree as TryConvert>::try_convert(args[1])?)
+        } else {
+            None
+        };
+
+        let language_name = self.language_name.borrow().clone().ok_or_else(|| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                "No language set. Call `parser.language = 'name'` first.",
+            )
+        })?;
+
+        let mut parser = self.inner.borrow_mut();
+        let old_ts_tree = old_tree.map(|t| (*t.inner).clone());
+
+        let timeout = *self.timeout_micros.borrow();
+        let result = if timeout > 0 {
+            let start = Instant::now();
+            let source_bytes = source.as_bytes();
+            let mut progress_callback =
+                |_: &tree_sitter::ParseState| start.elapsed().as_micros() < timeout as u128;
+            let options =
+                tree_sitter::ParseOptions::new().progress_callback(&mut progress_callback);
+            let mut source_callback = |offset: usize, _: tree_sitter::Point| {
+                if offset < source_bytes.len() {
+                    &source_bytes[offset..]
+                } else {
+                    &[]
+                }
+            };
+            parser.parse_with_options(&mut source_callback, old_ts_tree.as_ref(), Some(options))
+        } else {
+            parser.parse(&source, old_ts_tree.as_ref())
+        };
+
+        match result {
+            Some(tree) => Ok(Some(Tree::new(tree, source, language_name))),
+            None => Ok(None),
+        }
+    }
+
+    pub fn timeout_micros(&self) -> u64 {
+        *self.timeout_micros.borrow()
+    }
+
+    pub fn set_timeout_micros(&self, timeout: u64) {
+        *self.timeout_micros.borrow_mut() = timeout;
+    }
+
+    pub fn reset(&self) {
+        self.inner.borrow_mut().reset();
+    }
+}