tree_stump 0.1.0

data/ext/tree_stump/src/lib.rs

@@ -0,0 +1,311 @@
+use magnus::{function, method, prelude::*, typed_data, value::Lazy, Error, RClass, Ruby};
+
+use libloading::Library;
+use tree_sitter::ffi::TSLanguage;
+
+use std::collections::HashMap;
+use std::sync::Mutex;
+use std::sync::OnceLock;
+
+mod data;
+mod language;
+mod parser;
+mod query;
+mod tree;
+mod util;
+
+use crate::language::{LanguageRef, LookaheadIterator};
+use crate::parser::Parser;
+use crate::query::{Query, QueryCursor, QueryMatch};
+use crate::tree::{Node, Tree, TreeCursor};
+
+pub static LANG_LIBRARIES: OnceLock<Mutex<HashMap<String, Library>>> = OnceLock::new();
+pub static LANG_LANGUAGES: OnceLock<Mutex<HashMap<String, tree_sitter::Language>>> =
+    OnceLock::new();
+
+pub static QUERY_CAPTURE_CLASS: Lazy<RClass> =
+    Lazy::new(|ruby| ruby.define_struct(None, ("node", "index")).unwrap());
+
+fn register_lang(lang: String, path: String) -> () {
+    let func_name = String::from("tree_sitter_") + &lang;
+    let language;
+
+    let libraries = LANG_LIBRARIES.get_or_init(|| Mutex::new(HashMap::new()));
+    let languages = LANG_LANGUAGES.get_or_init(|| Mutex::new(HashMap::new()));
+
+    unsafe {
+        let mut libraries = libraries.lock().unwrap();
+        let lib = libraries.entry(lang.clone()).or_insert_with(|| {
+            let loaded = Library::new(path).expect("Failed to load library");
+            loaded
+        });
+
+        let func: libloading::Symbol<unsafe extern "C" fn() -> *const TSLanguage> =
+            lib.get(func_name.as_bytes()).unwrap();
+
+        language = tree_sitter::Language::from_raw(func());
+
+        let mut languages = languages.lock().unwrap();
+        languages.insert(lang.to_string(), language);
+    };
+}
+
+fn available_langs() -> Vec<String> {
+    let languages = LANG_LANGUAGES.get_or_init(|| Mutex::new(HashMap::new()));
+    let languages = languages.lock().unwrap();
+    languages.keys().cloned().collect()
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let namespace = ruby.define_module("TreeStump")?;
+    namespace.define_singleton_method("register_lang", function!(register_lang, 2))?;
+    namespace.define_singleton_method("available_langs", function!(available_langs, 0))?;
+
+    let parser_class = namespace.define_class("Parser", ruby.class_object())?;
+    parser_class.define_singleton_method("new", function!(Parser::new, 0))?;
+    parser_class.define_method("set_language", method!(Parser::set_language, 1))?;
+    parser_class.define_method("parse", method!(Parser::parse, 1))?;
+    parser_class.define_method("reset", method!(Parser::reset, 0))?;
+    parser_class.define_method("timeout_micros", method!(Parser::timeout_micros, 0))?;
+    parser_class.define_method("set_timeout_micros", method!(Parser::set_timeout_micros, 1))?;
+    parser_class.define_method("build_query", method!(Parser::build_query, 1))?;
+
+    let tree_class = namespace.define_class("Tree", ruby.class_object())?;
+    tree_class.define_method("root_node", method!(Tree::root_node, 0))?;
+    tree_class.define_method("language", method!(Tree::language, 0))?;
+    tree_class.define_method("walk", method!(Tree::walk, 0))?;
+    tree_class.define_method("print_dot_graph", method!(Tree::print_dot_graph, 1))?;
+    tree_class.define_method("inspect", method!(Tree::inspect, 0))?;
+
+    let tree_cursor_class = namespace.define_class("TreeCursor", ruby.class_object())?;
+    tree_cursor_class.define_method("node", method!(TreeCursor::node, 0))?;
+    tree_cursor_class.define_method("field_id", method!(TreeCursor::field_id, 0))?;
+    tree_cursor_class
+        .define_method("goto_first_child", method!(TreeCursor::goto_first_child, 0))?;
+    tree_cursor_class.define_method("goto_last_child", method!(TreeCursor::goto_last_child, 0))?;
+    tree_cursor_class.define_method("goto_parent", method!(TreeCursor::goto_parent, 0))?;
+    tree_cursor_class.define_method(
+        "goto_next_sibling",
+        method!(TreeCursor::goto_next_sibling, 0),
+    )?;
+    tree_cursor_class.define_method("goto_descendant", method!(TreeCursor::goto_descendant, 1))?;
+    tree_cursor_class.define_method(
+        "goto_previous_sibling",
+        method!(TreeCursor::goto_previous_sibling, 0),
+    )?;
+    tree_cursor_class.define_method(
+        "goto_first_child_for_byte",
+        method!(TreeCursor::goto_first_child_for_byte, 1),
+    )?;
+    tree_cursor_class.define_method("reset", method!(TreeCursor::reset, 1))?;
+    tree_cursor_class.define_method("reset_to", method!(TreeCursor::reset_to, 1))?;
+
+    let node_class = namespace.define_class("Node", ruby.class_object())?;
+    node_class.define_method("hash", method!(<Node as typed_data::Hash>::hash, 0))?;
+    node_class.define_method("==", method!(<Node as typed_data::IsEql>::is_eql, 1))?;
+    node_class.define_method("eql?", method!(<Node as typed_data::IsEql>::is_eql, 1))?;
+    node_class.define_method("id", method!(Node::id, 0))?;
+    node_class.define_method("kind", method!(Node::kind, 0))?;
+    node_class.define_method("kind_id", method!(Node::kind_id, 0))?;
+    node_class.define_method("grammar_id", method!(Node::grammar_id, 0))?;
+    node_class.define_method("grammar_name", method!(Node::grammar_name, 0))?;
+    node_class.define_method("language", method!(Node::language, 0))?;
+    node_class.define_method("is_named?", method!(Node::is_named, 0))?;
+    node_class.define_method("is_extra?", method!(Node::is_extra, 0))?;
+    node_class.define_method("has_changes?", method!(Node::has_changes, 0))?;
+    node_class.define_method("has_error?", method!(Node::has_error, 0))?;
+    node_class.define_method("is_error?", method!(Node::is_error, 0))?;
+    node_class.define_method("parse_state", method!(Node::parse_state, 0))?;
+    node_class.define_method("next_parse_state", method!(Node::next_parse_state, 0))?;
+    node_class.define_method("start_byte", method!(Node::start_byte, 0))?;
+    node_class.define_method("end_byte", method!(Node::end_byte, 0))?;
+    node_class.define_method("byte_range", method!(Node::byte_range, 0))?;
+    node_class.define_method("range", method!(Node::range, 0))?;
+    node_class.define_method("start_position", method!(Node::start_position, 0))?;
+    node_class.define_method("end_position", method!(Node::end_position, 0))?;
+    node_class.define_method("child", method!(Node::child, 1))?;
+    node_class.define_method("child_count", method!(Node::child_count, 0))?;
+    node_class.define_method("named_child", method!(Node::named_child, 1))?;
+    node_class.define_method("named_child_count", method!(Node::named_child_count, 0))?;
+    node_class.define_method("child_by_field_name", method!(Node::child_by_field_name, 1))?;
+    node_class.define_method("child_by_field_id", method!(Node::child_by_field_id, 1))?;
+    node_class.define_method(
+        "field_name_for_child",
+        method!(Node::field_name_for_child, 1),
+    )?;
+    node_class.define_method("parent", method!(Node::parent, 0))?;
+    node_class.define_method("children", method!(Node::children, 0))?;
+    node_class.define_method(
+        "children_with_cursor",
+        method!(Node::children_with_cursor, 1),
+    )?;
+    node_class.define_method(
+        "named_children_with_cursor",
+        method!(Node::named_children_with_cursor, 1),
+    )?;
+    node_class.define_method(
+        "children_by_field_name_with_cursor",
+        method!(Node::children_by_field_name_with_cursor, 2),
+    )?;
+    node_class.define_method(
+        "children_by_field_id_with_cursor",
+        method!(Node::children_by_field_id_with_cursor, 2),
+    )?;
+    node_class.define_method(
+        "child_containing_descendant",
+        method!(Node::child_containing_descendant, 1),
+    )?;
+    node_class.define_method("next_sibling", method!(Node::next_sibling, 0))?;
+    node_class.define_method("prev_sibling", method!(Node::prev_sibling, 0))?;
+    node_class.define_method("next_named_sibling", method!(Node::next_named_sibling, 0))?;
+    node_class.define_method("prev_named_sibling", method!(Node::prev_named_sibling, 0))?;
+    node_class.define_method("descendant_count", method!(Node::descendant_count, 0))?;
+    node_class.define_method(
+        "descendant_for_byte_range",
+        method!(Node::descendant_for_byte_range, 2),
+    )?;
+    node_class.define_method(
+        "named_descendant_for_byte_range",
+        method!(Node::named_descendant_for_byte_range, 2),
+    )?;
+    node_class.define_method(
+        "descendant_for_point_range",
+        method!(Node::descendant_for_point_range, 2),
+    )?;
+    node_class.define_method(
+        "named_descendant_for_point_range",
+        method!(Node::named_descendant_for_point_range, 2),
+    )?;
+
+    node_class.define_method("to_sexp", method!(Node::to_sexp, 0))?;
+    node_class.define_method("utf8_text", method!(Node::utf8_text, 1))?;
+    node_class.define_method("walk", method!(Node::walk, 0))?;
+
+    node_class.define_method("inspect", method!(Node::inspect, 0))?;
+    node_class.define_method("to_s", method!(Node::to_s, 0))?;
+
+    let point_class = namespace.define_class("Point", ruby.class_object())?;
+    point_class.define_singleton_method("new", function!(data::Point::new, 2))?;
+    point_class.define_method("hash", method!(<data::Point as typed_data::Hash>::hash, 0))?;
+    point_class.define_method("==", method!(<data::Point as typed_data::IsEql>::is_eql, 1))?;
+    point_class.define_method(
+        "eql?",
+        method!(<data::Point as typed_data::IsEql>::is_eql, 1),
+    )?;
+    point_class.define_method("row", method!(data::Point::get_row, 0))?;
+    point_class.define_method("column", method!(data::Point::get_column, 0))?;
+    point_class.define_method("inspect", method!(data::Point::inspect, 0))?;
+    point_class.define_method("to_s", method!(data::Point::to_s, 0))?;
+
+    let range_class = namespace.define_class("Range", ruby.class_object())?;
+    range_class.define_singleton_method("new", function!(data::Range::new, 4))?;
+    range_class.define_method("hash", method!(<data::Range as typed_data::Hash>::hash, 0))?;
+    range_class.define_method("==", method!(<data::Range as typed_data::IsEql>::is_eql, 1))?;
+    range_class.define_method(
+        "eql?",
+        method!(<data::Range as typed_data::IsEql>::is_eql, 1),
+    )?;
+    range_class.define_method("start_byte", method!(data::Range::get_start_byte, 0))?;
+    range_class.define_method("end_byte", method!(data::Range::get_end_byte, 0))?;
+    range_class.define_method("start_point", method!(data::Range::get_start_point, 0))?;
+    range_class.define_method("end_point", method!(data::Range::get_end_point, 0))?;
+    range_class.define_method("inspect", method!(data::Range::inspect, 0))?;
+    range_class.define_method("to_s", method!(data::Range::to_s, 0))?;
+
+    let language_class = namespace.define_class("LanguageRef", ruby.class_object())?;
+    language_class.define_method("version", method!(LanguageRef::version, 0))?;
+    language_class.define_method("node_kind_count", method!(LanguageRef::node_kind_count, 0))?;
+    language_class.define_method(
+        "parse_state_count",
+        method!(LanguageRef::parse_state_count, 0),
+    )?;
+    language_class.define_method(
+        "node_kind_for_id",
+        method!(LanguageRef::node_kind_for_id, 1),
+    )?;
+    language_class.define_method(
+        "id_for_node_kind",
+        method!(LanguageRef::id_for_node_kind, 2),
+    )?;
+    language_class.define_method(
+        "node_kind_is_named",
+        method!(LanguageRef::node_kind_is_named, 1),
+    )?;
+    language_class.define_method(
+        "node_kind_is_visible",
+        method!(LanguageRef::node_kind_is_visible, 1),
+    )?;
+    language_class.define_method(
+        "field_name_for_id",
+        method!(LanguageRef::field_name_for_id, 1),
+    )?;
+    language_class.define_method(
+        "field_id_for_name",
+        method!(LanguageRef::field_id_for_name, 1),
+    )?;
+    language_class.define_method("next_state", method!(LanguageRef::next_state, 2))?;
+    language_class.define_method(
+        "lookahead_iterator",
+        method!(LanguageRef::lookahead_iterator, 1),
+    )?;
+
+    let lookahead_iterator_class =
+        namespace.define_class("LookaheadIterator", ruby.class_object())?;
+    lookahead_iterator_class.define_method("next", method!(LookaheadIterator::next, 0))?;
+    lookahead_iterator_class.define_method(
+        "current_symbol_name",
+        method!(LookaheadIterator::current_symbol_name, 0),
+    )?;
+
+    let query_class = namespace.define_class("Query", ruby.class_object())?;
+    query_class.define_method(
+        "start_byte_for_pattern",
+        method!(Query::start_byte_for_pattern, 1),
+    )?;
+    query_class.define_method("pattern_count", method!(Query::pattern_count, 0))?;
+    query_class.define_method("capture_names", method!(Query::capture_names, 0))?;
+    query_class.define_method(
+        "capture_quantifiers",
+        method!(Query::capture_quantifiers, 1),
+    )?;
+    query_class.define_method(
+        "capture_index_for_name",
+        method!(Query::capture_index_for_name, 1),
+    )?;
+    query_class.define_method("disable_capture", method!(Query::disable_capture, 1))?;
+    query_class.define_method("disable_pattern", method!(Query::disable_pattern, 1))?;
+    query_class.define_method("is_pattern_rooted", method!(Query::is_pattern_rooted, 1))?;
+    query_class.define_method(
+        "is_pattern_guaranteed_at_step",
+        method!(Query::is_pattern_guaranteed_at_step, 1),
+    )?;
+
+    Lazy::force(&QUERY_CAPTURE_CLASS, ruby);
+    let struct_class = Lazy::try_get_inner(&QUERY_CAPTURE_CLASS).unwrap();
+    namespace.const_set("QueryCapture", struct_class)?;
+
+    let query_match_class = namespace.define_class("QueryMatch", ruby.class_object())?;
+    query_match_class.define_method("pattern_index", method!(QueryMatch::pattern_index, 0))?;
+    query_match_class.define_method("captures", method!(QueryMatch::captures, 0))?;
+
+    let query_cursor_class = namespace.define_class("QueryCursor", ruby.class_object())?;
+    query_cursor_class.define_singleton_method("new", function!(QueryCursor::new, 0))?;
+    query_cursor_class.define_method("match_limit", method!(QueryCursor::match_limit, 0))?;
+    query_cursor_class
+        .define_method("set_match_limit", method!(QueryCursor::set_match_limit, 1))?;
+    query_cursor_class.define_method(
+        "did_exceed_match_limit",
+        method!(QueryCursor::did_exceed_match_limit, 0),
+    )?;
+    query_cursor_class.define_method("matches", method!(QueryCursor::matches, 3))?;
+    query_cursor_class.define_method("set_byte_range", method!(QueryCursor::set_byte_range, 1))?;
+    query_cursor_class
+        .define_method("set_point_range", method!(QueryCursor::set_point_range, 1))?;
+    query_cursor_class.define_method(
+        "set_max_start_depth",
+        method!(QueryCursor::set_max_start_depth, 1),
+    )?;
+
+    Ok(())
+}

data/ext/tree_stump/src/parser.rs

@@ -0,0 +1,67 @@
+use crate::query::Query;
+use crate::tree::Tree;
+use crate::util::build_error;
+use crate::LANG_LANGUAGES;
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+#[magnus::wrap(class = "TreeStump::Parser")]
+pub struct Parser {
+    raw_parser: RefCell<tree_sitter::Parser>,
+}
+
+impl Parser {
+    pub fn new() -> Self {
+        Self {
+            raw_parser: RefCell::new(tree_sitter::Parser::new()),
+        }
+    }
+
+    pub fn set_language(&self, lang: String) -> Result<bool, magnus::Error> {
+        let languages = LANG_LANGUAGES.get_or_init(|| Mutex::new(HashMap::new()));
+        let languages = languages.lock().unwrap();
+        let language = languages.get(&lang);
+        match language {
+            Some(language) => {
+                let result = self.raw_parser.borrow_mut().set_language(language);
+                result.map_or_else(|e| Err(build_error(e.to_string())), |_| Ok(true))
+            }
+            None => Err(build_error(format!("Language {} is not registered", lang))),
+        }
+    }
+
+    pub fn parse(&self, source: String) -> Result<Tree, magnus::Error> {
+        let tree = self.raw_parser.borrow_mut().parse(source, None);
+
+        match tree {
+            Some(tree) => Ok(Tree::from(Arc::new(tree))),
+            None => Err(build_error("Failed to parse")),
+        }
+    }
+
+    pub fn reset(&self) {
+        self.raw_parser.borrow_mut().reset();
+    }
+
+    pub fn timeout_micros(&self) -> u64 {
+        self.raw_parser.borrow().timeout_micros()
+    }
+
+    pub fn set_timeout_micros(&self, timeout: u64) {
+        self.raw_parser.borrow_mut().set_timeout_micros(timeout);
+    }
+
+    fn language(&self) -> Option<tree_sitter::Language> {
+        self.raw_parser.borrow().language()
+    }
+
+    pub fn build_query(&self, source: String) -> Result<Query, magnus::Error> {
+        let lang = self.language();
+        lang.map_or_else(
+            || Err(build_error("Failed to get language from parser")),
+            |lang| Query::new(&lang, source),
+        )
+    }
+}

data/ext/tree_stump/src/query.rs

@@ -0,0 +1,209 @@
+use std::{cell::RefCell, sync::Arc};
+
+use magnus::{
+    block::Yield,
+    symbol::IntoSymbol,
+    typed_data,
+    value::{InnerRef, Opaque, ReprValue},
+    Class, Error, IntoValue, RArray, RStruct, RTypedData, Ruby, Value,
+};
+
+use crate::{data::Point, tree::Node, util::build_error, QUERY_CAPTURE_CLASS};
+
+#[magnus::wrap(class = "TreeStump::Query", free_immediately)]
+#[derive(Debug)]
+pub struct Query {
+    pub raw_query: RefCell<tree_sitter::Query>,
+}
+
+impl Query {
+    pub fn new(language: &tree_sitter::Language, source: String) -> Result<Self, magnus::Error> {
+        let raw_query = tree_sitter::Query::new(language, source.as_str());
+        let raw_query = raw_query.map_err(|e| build_error(e.to_string()));
+        raw_query.map(|q| Self {
+            raw_query: RefCell::new(q),
+        })
+    }
+
+    pub fn start_byte_for_pattern(&self, pattern_index: usize) -> usize {
+        self.raw_query
+            .borrow()
+            .start_byte_for_pattern(pattern_index)
+    }
+
+    pub fn pattern_count(&self) -> usize {
+        self.raw_query.borrow().pattern_count()
+    }
+
+    pub fn capture_names(&self) -> Vec<String> {
+        self.raw_query
+            .borrow()
+            .capture_names()
+            .iter()
+            .map(|s| s.to_string())
+            .collect()
+    }
+
+    pub fn capture_quantifiers(&self, index: usize) -> Result<RArray, Error> {
+        let raw_query = self.raw_query.borrow();
+        let quantifiers = raw_query
+            .capture_quantifiers(index)
+            .iter()
+            .map(|q| format!("{:?}", q).into_symbol());
+        let ruby = Ruby::get().expect("Ruby is not initialized");
+        let array = ruby.ary_from_iter(quantifiers);
+        Ok(array)
+    }
+
+    pub fn capture_index_for_name(&self, name: String) -> Option<u32> {
+        self.raw_query
+            .borrow()
+            .capture_index_for_name(name.as_str())
+    }
+
+    pub fn disable_capture(&self, name: String) {
+        self.raw_query.borrow_mut().disable_capture(&name);
+    }
+
+    pub fn disable_pattern(&self, index: usize) {
+        self.raw_query.borrow_mut().disable_pattern(index);
+    }
+
+    pub fn is_pattern_rooted(&self, index: usize) -> bool {
+        self.raw_query.borrow().is_pattern_rooted(index)
+    }
+
+    pub fn is_pattern_guaranteed_at_step(&self, index: usize) -> bool {
+        self.raw_query.borrow().is_pattern_guaranteed_at_step(index)
+    }
+}
+
+#[magnus::wrap(class = "TreeStump::QueryMatch", free_immediately)]
+pub struct QueryMatch {
+    pattern_index: usize,
+    captures: Opaque<RArray>,
+}
+
+impl QueryMatch {
+    pub fn pattern_index(&self) -> usize {
+        self.pattern_index
+    }
+
+    pub fn captures(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        Ok(ruby.get_inner(rb_self.captures))
+    }
+}
+
+#[magnus::wrap(class = "TreeStump::QueryCursor", free_immediately)]
+pub struct QueryCursor {
+    raw_cursor: RefCell<tree_sitter::QueryCursor>,
+}
+
+impl QueryCursor {
+    pub fn new() -> Self {
+        Self {
+            raw_cursor: RefCell::new(tree_sitter::QueryCursor::new()),
+        }
+    }
+
+    pub fn match_limit(&self) -> u32 {
+        self.raw_cursor.borrow().match_limit()
+    }
+
+    pub fn set_match_limit(&self, limit: u32) {
+        self.raw_cursor.borrow_mut().set_match_limit(limit);
+    }
+
+    pub fn did_exceed_match_limit(&self) -> bool {
+        self.raw_cursor.borrow().did_exceed_match_limit()
+    }
+
+    pub fn matches<'tree>(
+        ruby: &Ruby,
+        rb_self: typed_data::Obj<Self>,
+        query: typed_data::Obj<Query>,
+        node: typed_data::Obj<Node<'tree>>,
+        source: String,
+    ) -> Result<Yield<impl Iterator<Item = Value>>, Error> {
+        let mut cursor = rb_self.raw_cursor.borrow_mut();
+        let raw_query = query.raw_query.borrow();
+
+        let matches = cursor.matches(&raw_query, node.get_raw_node(), source.as_bytes());
+        let struct_class = QUERY_CAPTURE_CLASS.get_inner_ref_with(ruby);
+        let array = ruby.ary_new();
+
+        for m in matches {
+            let captures = ruby.ary_new();
+            for c in m.captures {
+                let r_struct = RStruct::from_value(
+                    struct_class
+                        .new_instance((Node::new(Arc::clone(&node.raw_tree), c.node), c.index))?,
+                );
+                captures.push(r_struct)?
+            }
+            let query_match = QueryMatch {
+                pattern_index: m.pattern_index,
+                captures: Opaque::from(captures),
+            };
+            array.push(query_match)?
+        }
+
+        if ruby.block_given() {
+            Ok(Yield::Iter(array.into_iter()))
+        } else {
+            Ok(Yield::Enumerator(rb_self.enumeratorize(
+                "matches",
+                (query, node, source.into_value()),
+            )))
+        }
+    }
+
+    pub fn set_byte_range(
+        _ruby: &Ruby,
+        rb_self: typed_data::Obj<Self>,
+        range: magnus::Range,
+    ) -> Result<typed_data::Obj<Self>, Error> {
+        let mut cursor = rb_self.raw_cursor.borrow_mut();
+        let len = range.funcall("size", ())?;
+        let std_range = range.to_range_with_len(len)?;
+        cursor.set_byte_range(std_range);
+        Ok(rb_self)
+    }
+
+    pub fn set_point_range(
+        _ruby: &Ruby,
+        rb_self: typed_data::Obj<Self>,
+        range: magnus::Range,
+    ) -> Result<typed_data::Obj<Self>, Error> {
+        let excl = range.excl();
+
+        if excl {
+            return Err(build_error("Point range must be inclusive"));
+        }
+
+        let start: Value = range.beg()?;
+        let end: Value = range.end()?;
+
+        let start_typed_data = RTypedData::from_value(start).expect("Expected typed data");
+        let start = start_typed_data.get::<Point>()?;
+
+        let end_typed_data = RTypedData::from_value(end).expect("Expected typed data");
+        let end = end_typed_data.get::<Point>()?;
+
+        let point_range = start.into_raw()..end.into_raw();
+
+        let mut cursor = rb_self.raw_cursor.borrow_mut();
+        cursor.set_point_range(point_range);
+        Ok(rb_self)
+    }
+
+    pub fn set_max_start_depth(
+        _ruby: &Ruby,
+        rb_self: typed_data::Obj<Self>,
+        depth: Option<u32>,
+    ) -> Result<typed_data::Obj<Self>, Error> {
+        let mut cursor = rb_self.raw_cursor.borrow_mut();
+        cursor.set_max_start_depth(depth);
+        Ok(rb_self)
+    }
+}