tree_sitter_language_pack 1.8.0 → 1.8.1

data/ext/ts_pack_core_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:eed307d857d74c9dce2d6a626941327b2f9e3442eaa781b0e2191b8f8b470855
+// alef:hash:2b779fd4a6411cbf6f73ed90dc178998e48f73f245c189530e77b9cad8d334d5
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -13,12 +13,16 @@
     clippy::unwrap_or_default,
     clippy::derivable_impls,
     clippy::needless_borrows_for_generic_args,
-    clippy::unnecessary_fallible_conversions
+    clippy::unnecessary_fallible_conversions,
+    clippy::type_complexity,
+    clippy::useless_conversion,
+    clippy::clone_on_copy
 )]
 
 use magnus::{Error, IntoValueFromNative, Ruby, function, method, prelude::*, try_convert::TryConvertOwned};
 use std::collections::HashMap;
 use std::sync::Arc;
+use std::sync::Mutex;
 
 fn json_to_ruby(handle: &Ruby, val: serde_json::Value) -> magnus::Value {
     use magnus::IntoValue;
@@ -423,7 +427,7 @@ impl FileMetrics {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::StructureItem")]
 pub struct StructureItem {
@@ -466,6 +470,22 @@ impl magnus::TryConvert for StructureItem {
 
 unsafe impl TryConvertOwned for StructureItem {}
 
+impl Default for StructureItem {
+    fn default() -> Self {
+        Self {
+            kind: Default::default(),
+            name: None,
+            visibility: None,
+            span: Default::default(),
+            children: vec![],
+            decorators: vec![],
+            doc_comment: None,
+            signature: None,
+            body_span: None,
+        }
+    }
+}
+
 impl StructureItem {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -544,7 +564,7 @@ impl StructureItem {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::CommentInfo")]
 pub struct CommentInfo {
@@ -582,6 +602,17 @@ impl magnus::TryConvert for CommentInfo {
 
 unsafe impl TryConvertOwned for CommentInfo {}
 
+impl Default for CommentInfo {
+    fn default() -> Self {
+        Self {
+            text: String::new(),
+            kind: Default::default(),
+            span: Default::default(),
+            associated_node: None,
+        }
+    }
+}
+
 impl CommentInfo {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -624,7 +655,7 @@ impl CommentInfo {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::DocstringInfo")]
 pub struct DocstringInfo {
@@ -663,6 +694,18 @@ impl magnus::TryConvert for DocstringInfo {
 
 unsafe impl TryConvertOwned for DocstringInfo {}
 
+impl Default for DocstringInfo {
+    fn default() -> Self {
+        Self {
+            text: String::new(),
+            format: Default::default(),
+            span: Default::default(),
+            associated_item: None,
+            parsed_sections: vec![],
+        }
+    }
+}
+
 impl DocstringInfo {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -885,7 +928,7 @@ impl ImportInfo {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::ExportInfo")]
 pub struct ExportInfo {
@@ -922,6 +965,16 @@ impl magnus::TryConvert for ExportInfo {
 
 unsafe impl TryConvertOwned for ExportInfo {}
 
+impl Default for ExportInfo {
+    fn default() -> Self {
+        Self {
+            name: String::new(),
+            kind: Default::default(),
+            span: Default::default(),
+        }
+    }
+}
+
 impl ExportInfo {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -957,7 +1010,7 @@ impl ExportInfo {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::SymbolInfo")]
 pub struct SymbolInfo {
@@ -996,6 +1049,18 @@ impl magnus::TryConvert for SymbolInfo {
 
 unsafe impl TryConvertOwned for SymbolInfo {}
 
+impl Default for SymbolInfo {
+    fn default() -> Self {
+        Self {
+            name: String::new(),
+            kind: Default::default(),
+            span: Default::default(),
+            type_annotation: None,
+            doc: None,
+        }
+    }
+}
+
 impl SymbolInfo {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1045,7 +1110,7 @@ impl SymbolInfo {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::Diagnostic")]
 pub struct Diagnostic {
@@ -1082,6 +1147,16 @@ impl magnus::TryConvert for Diagnostic {
 
 unsafe impl TryConvertOwned for Diagnostic {}
 
+impl Default for Diagnostic {
+    fn default() -> Self {
+        Self {
+            message: String::new(),
+            severity: Default::default(),
+            span: Default::default(),
+        }
+    }
+}
+
 impl Diagnostic {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1434,6 +1509,360 @@ impl PackConfig {
     }
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::Point")]
+pub struct Point {
+    row: usize,
+    column: usize,
+}
+
+unsafe impl IntoValueFromNative for Point {}
+
+impl magnus::TryConvert for Point {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&Point as magnus::TryConvert>::try_convert(val) {
+            return Ok(r.clone());
+        }
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into Point: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<Point>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize Point: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for Point {}
+
+impl Point {
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            row: kwargs
+                .get(ruby.to_symbol("row"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            column: kwargs
+                .get(ruby.to_symbol("column"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
+    }
+
+    fn row(&self) -> usize {
+        self.row
+    }
+
+    fn column(&self) -> usize {
+        self.column
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::ByteRange")]
+pub struct ByteRange {
+    start: usize,
+    end: usize,
+}
+
+unsafe impl IntoValueFromNative for ByteRange {}
+
+impl magnus::TryConvert for ByteRange {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&ByteRange as magnus::TryConvert>::try_convert(val) {
+            return Ok(r.clone());
+        }
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into ByteRange: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<ByteRange>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize ByteRange: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for ByteRange {}
+
+impl ByteRange {
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            start: kwargs
+                .get(ruby.to_symbol("start"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            end: kwargs
+                .get(ruby.to_symbol("end"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
+    }
+
+    fn start(&self) -> usize {
+        self.start
+    }
+
+    fn end(&self) -> usize {
+        self.end
+    }
+}
+
+#[derive(Clone)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::Parser")]
+pub struct Parser {
+    inner: Arc<std::sync::Mutex<tree_sitter_language_pack::Parser>>,
+}
+
+unsafe impl IntoValueFromNative for Parser {}
+
+impl magnus::TryConvert for Parser {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &Parser = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+
+unsafe impl TryConvertOwned for Parser {}
+
+impl Parser {
+    fn set_language(&self, name: String) -> Result<(), Error> {
+        self.inner.lock().unwrap().set_language(&name).map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        Ok(())
+    }
+
+    fn parse(&self, source: String) -> Option<Tree> {
+        self.inner
+            .lock()
+            .unwrap()
+            .parse(&source)
+            .map(|v| Tree { inner: Arc::new(v) })
+    }
+
+    fn parse_bytes(&self, source: Vec<u8>) -> Option<Tree> {
+        self.inner
+            .lock()
+            .unwrap()
+            .parse_bytes(&source)
+            .map(|v| Tree { inner: Arc::new(v) })
+    }
+
+    fn reset(&self) -> () {
+        self.inner.lock().unwrap().reset()
+    }
+}
+
+#[derive(Clone)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::Tree")]
+pub struct Tree {
+    inner: Arc<tree_sitter_language_pack::Tree>,
+}
+
+unsafe impl IntoValueFromNative for Tree {}
+
+impl magnus::TryConvert for Tree {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &Tree = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+
+unsafe impl TryConvertOwned for Tree {}
+
+impl Tree {
+    fn root_node(&self) -> Node {
+        Node {
+            inner: Arc::new(self.inner.root_node()),
+        }
+    }
+
+    fn walk(&self) -> TreeCursor {
+        TreeCursor {
+            inner: Arc::new(std::sync::Mutex::new(self.inner.walk())),
+        }
+    }
+}
+
+#[derive(Clone)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::Node")]
+pub struct Node {
+    inner: Arc<tree_sitter_language_pack::Node>,
+}
+
+unsafe impl IntoValueFromNative for Node {}
+
+impl magnus::TryConvert for Node {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &Node = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+
+unsafe impl TryConvertOwned for Node {}
+
+impl Node {
+    fn clone(&self) -> Node {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+
+    fn kind(&self) -> String {
+        self.inner.kind()
+    }
+
+    fn kind_id(&self) -> u16 {
+        self.inner.kind_id()
+    }
+
+    fn start_byte(&self) -> usize {
+        self.inner.start_byte()
+    }
+
+    fn end_byte(&self) -> usize {
+        self.inner.end_byte()
+    }
+
+    fn byte_range(&self) -> ByteRange {
+        self.inner.byte_range().into()
+    }
+
+    fn start_position(&self) -> Point {
+        self.inner.start_position().into()
+    }
+
+    fn end_position(&self) -> Point {
+        self.inner.end_position().into()
+    }
+
+    fn is_named(&self) -> bool {
+        self.inner.is_named()
+    }
+
+    fn is_error(&self) -> bool {
+        self.inner.is_error()
+    }
+
+    fn is_missing(&self) -> bool {
+        self.inner.is_missing()
+    }
+
+    fn is_extra(&self) -> bool {
+        self.inner.is_extra()
+    }
+
+    fn has_error(&self) -> bool {
+        self.inner.has_error()
+    }
+
+    fn parent(&self) -> Option<Node> {
+        self.inner.parent().map(|v| Node { inner: Arc::new(v) })
+    }
+
+    fn child(&self, index: u32) -> Option<Node> {
+        self.inner.child(index).map(|v| Node { inner: Arc::new(v) })
+    }
+
+    fn child_count(&self) -> usize {
+        self.inner.child_count()
+    }
+
+    fn named_child(&self, index: u32) -> Option<Node> {
+        self.inner.named_child(index).map(|v| Node { inner: Arc::new(v) })
+    }
+
+    fn named_child_count(&self) -> usize {
+        self.inner.named_child_count()
+    }
+
+    fn child_by_field_name(&self, name: String) -> Option<Node> {
+        self.inner
+            .child_by_field_name(&name)
+            .map(|v| Node { inner: Arc::new(v) })
+    }
+
+    fn to_sexp(&self) -> String {
+        self.inner.to_sexp()
+    }
+
+    fn walk(&self) -> TreeCursor {
+        TreeCursor {
+            inner: Arc::new(std::sync::Mutex::new(self.inner.walk())),
+        }
+    }
+}
+
+#[derive(Clone)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::TreeCursor")]
+pub struct TreeCursor {
+    inner: Arc<std::sync::Mutex<tree_sitter_language_pack::TreeCursor>>,
+}
+
+unsafe impl IntoValueFromNative for TreeCursor {}
+
+impl magnus::TryConvert for TreeCursor {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &TreeCursor = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+
+unsafe impl TryConvertOwned for TreeCursor {}
+
+impl TreeCursor {
+    fn node(&self) -> Node {
+        Node {
+            inner: Arc::new(self.inner.lock().unwrap().node()),
+        }
+    }
+
+    fn goto_first_child(&self) -> bool {
+        self.inner.lock().unwrap().goto_first_child()
+    }
+
+    fn goto_parent(&self) -> bool {
+        self.inner.lock().unwrap().goto_parent()
+    }
+
+    fn goto_next_sibling(&self) -> bool {
+        self.inner.lock().unwrap().goto_next_sibling()
+    }
+
+    fn field_name(&self) -> Option<String> {
+        self.inner.lock().unwrap().field_name()
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::ProcessConfig")]
@@ -1681,14 +2110,18 @@ impl LanguageRegistry {
     }
 
     fn process(&self, source: String, config: ProcessConfig) -> Result<ProcessResult, Error> {
-        Err(magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            "Not implemented: process",
-        ))
+        let config_core: tree_sitter_language_pack::ProcessConfig = config.into();
+        let result = self.inner.process(&source, &config_core).map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        Ok(result.into())
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::ParserManifest")]
 pub struct ParserManifest {
     version: String,
@@ -1768,7 +2201,7 @@ impl ParserManifest {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::PlatformBundle")]
 pub struct PlatformBundle {
     url: String,
@@ -1839,7 +2272,7 @@ impl PlatformBundle {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::LanguageInfo")]
 pub struct LanguageInfo {
     group: String,
@@ -1928,10 +2361,14 @@ impl DownloadManager {
     }
 
     fn ensure_languages(&self, names: Vec<String>) -> Result<(), Error> {
-        Err(magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            "Not implemented: ensure_languages",
-        ))
+        let names_refs: Vec<&str> = names.iter().map(|s| s.as_str()).collect();
+        self.inner.ensure_languages(&names_refs).map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        Ok(())
     }
 
     fn ensure_group(&self, group: String) -> Result<(), Error> {
@@ -1963,78 +2400,40 @@ impl DownloadManager {
             magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
                 e.to_string(),
-            )
-        })?;
-        Ok(result)
-    }
-
-    fn clean_cache(&self) -> Result<(), Error> {
-        self.inner.clean_cache().map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
-        Ok(())
-    }
-}
-
-#[derive(Clone)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::Language")]
-pub struct Language {
-    inner: Arc<tree_sitter_language_pack::Language>,
-}
-
-unsafe impl IntoValueFromNative for Language {}
-
-impl magnus::TryConvert for Language {
-    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let r: &Language = magnus::TryConvert::try_convert(val)?;
-        Ok(r.clone())
-    }
-}
-
-unsafe impl TryConvertOwned for Language {}
-
-impl Language {}
-
-#[derive(Clone)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::Parser")]
-pub struct Parser {
-    inner: Arc<tree_sitter_language_pack::Parser>,
-}
-
-unsafe impl IntoValueFromNative for Parser {}
+            )
+        })?;
+        Ok(result)
+    }
 
-impl magnus::TryConvert for Parser {
-    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let r: &Parser = magnus::TryConvert::try_convert(val)?;
-        Ok(r.clone())
+    fn clean_cache(&self) -> Result<(), Error> {
+        self.inner.clean_cache().map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        Ok(())
     }
 }
 
-unsafe impl TryConvertOwned for Parser {}
-
-impl Parser {}
-
 #[derive(Clone)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::Tree")]
-pub struct Tree {
-    inner: Arc<tree_sitter_language_pack::Tree>,
+#[magnus::wrap(class = "TreeSitterLanguagePack::Language")]
+pub struct Language {
+    inner: Arc<tree_sitter_language_pack::Language>,
 }
 
-unsafe impl IntoValueFromNative for Tree {}
+unsafe impl IntoValueFromNative for Language {}
 
-impl magnus::TryConvert for Tree {
+impl magnus::TryConvert for Language {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let r: &Tree = magnus::TryConvert::try_convert(val)?;
+        let r: &Language = magnus::TryConvert::try_convert(val)?;
         Ok(r.clone())
     }
 }
 
-unsafe impl TryConvertOwned for Tree {}
+unsafe impl TryConvertOwned for Language {}
 
-impl Tree {}
+impl Language {}
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum StructureKind {
@@ -2115,10 +2514,12 @@ impl magnus::IntoValue for CommentKind {
 impl magnus::TryConvert for CommentKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "line" => Ok(CommentKind::Line),
-            "block" => Ok(CommentKind::Block),
-            "doc" => Ok(CommentKind::Doc),
+            "line" | "Line" => Ok(CommentKind::Line),
+            "block" | "Block" => Ok(CommentKind::Block),
+            "doc" | "Doc" => Ok(CommentKind::Doc),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid CommentKind value: {other}"),
@@ -2204,10 +2605,12 @@ impl magnus::IntoValue for ExportKind {
 impl magnus::TryConvert for ExportKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "named" => Ok(ExportKind::Named),
-            "default" => Ok(ExportKind::Default),
-            "re_export" => Ok(ExportKind::ReExport),
+            "named" | "Named" => Ok(ExportKind::Named),
+            "default" | "Default" => Ok(ExportKind::Default),
+            "re_export" | "ReExport" => Ok(ExportKind::ReExport),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid ExportKind value: {other}"),
@@ -2296,10 +2699,12 @@ impl magnus::IntoValue for DiagnosticSeverity {
 impl magnus::TryConvert for DiagnosticSeverity {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "error" => Ok(DiagnosticSeverity::Error),
-            "warning" => Ok(DiagnosticSeverity::Warning),
-            "info" => Ok(DiagnosticSeverity::Info),
+            "error" | "Error" => Ok(DiagnosticSeverity::Error),
+            "warning" | "Warning" => Ok(DiagnosticSeverity::Warning),
+            "info" | "Info" => Ok(DiagnosticSeverity::Info),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid DiagnosticSeverity value: {other}"),
@@ -2355,7 +2760,7 @@ fn get_parser(name: String) -> Result<Parser, Error> {
         )
     })?;
     Ok(Parser {
-        inner: Arc::new(result),
+        inner: Arc::new(std::sync::Mutex::new(result)),
     })
 }
 
@@ -2378,7 +2783,9 @@ fn language_count() -> usize {
 fn process(args: &[magnus::Value]) -> Result<ProcessResult, Error> {
     let args = magnus::scan_args::scan_args::<(String,), (Option<magnus::Value>,), (), (), (), ()>(args)?;
     let (source,) = args.required;
+
     let (config,) = args.optional;
+
     let config_core: tree_sitter_language_pack::ProcessConfig = match config {
         Some(_v) if !_v.is_nil() => {
             let binding_val: ProcessConfig = ProcessConfig::try_convert(_v).map_err(|e| {
@@ -2403,6 +2810,7 @@ fn process(args: &[magnus::Value]) -> Result<ProcessResult, Error> {
 fn init(args: &[magnus::Value]) -> Result<(), Error> {
     let args = magnus::scan_args::scan_args::<(), (Option<magnus::Value>,), (), (), (), ()>(args)?;
     let (config,) = args.optional;
+
     let config_core: tree_sitter_language_pack::PackConfig = match config {
         Some(_v) if !_v.is_nil() => {
             let binding_val: PackConfig = PackConfig::try_convert(_v).map_err(|e| {
@@ -2427,6 +2835,7 @@ fn init(args: &[magnus::Value]) -> Result<(), Error> {
 fn configure(args: &[magnus::Value]) -> Result<(), Error> {
     let args = magnus::scan_args::scan_args::<(), (Option<magnus::Value>,), (), (), (), ()>(args)?;
     let (config,) = args.optional;
+
     let config_core: tree_sitter_language_pack::PackConfig = match config {
         Some(_v) if !_v.is_nil() => {
             let binding_val: PackConfig = PackConfig::try_convert(_v).map_err(|e| {
@@ -2885,6 +3294,46 @@ impl From<tree_sitter_language_pack::PackConfig> for PackConfig {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<Point> for tree_sitter_language_pack::Point {
+    fn from(val: Point) -> Self {
+        Self {
+            row: val.row,
+            column: val.column,
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<tree_sitter_language_pack::Point> for Point {
+    fn from(val: tree_sitter_language_pack::Point) -> Self {
+        Self {
+            row: val.row,
+            column: val.column,
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<ByteRange> for tree_sitter_language_pack::ByteRange {
+    fn from(val: ByteRange) -> Self {
+        Self {
+            start: val.start,
+            end: val.end,
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<tree_sitter_language_pack::ByteRange> for ByteRange {
+    fn from(val: tree_sitter_language_pack::ByteRange) -> Self {
+        Self {
+            start: val.start,
+            end: val.end,
+        }
+    }
+}
+
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ProcessConfig> for tree_sitter_language_pack::ProcessConfig {
     fn from(val: ProcessConfig) -> Self {
@@ -3150,214 +3599,440 @@ fn error_to_magnus_err(e: tree_sitter_language_pack::error::Error) -> magnus::Er
 fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("TreeSitterLanguagePack")?;
 
+    // Ensure JSON library is loaded for Hash#to_json
+    let _ = ruby.eval::<magnus::Value>("require \"json\"");
+
     let class = module.define_class("Span", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(Span::new, -1))?;
+
     class.define_method("start_byte", method!(Span::start_byte, 0))?;
+
     class.define_method("end_byte", method!(Span::end_byte, 0))?;
+
     class.define_method("start_line", method!(Span::start_line, 0))?;
+
     class.define_method("start_column", method!(Span::start_column, 0))?;
+
     class.define_method("end_line", method!(Span::end_line, 0))?;
+
     class.define_method("end_column", method!(Span::end_column, 0))?;
 
     let class = module.define_class("ProcessResult", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ProcessResult::new, -1))?;
+
     class.define_method("language", method!(ProcessResult::language, 0))?;
+
     class.define_method("metrics", method!(ProcessResult::metrics, 0))?;
+
     class.define_method("structure", method!(ProcessResult::structure, 0))?;
+
     class.define_method("imports", method!(ProcessResult::imports, 0))?;
+
     class.define_method("exports", method!(ProcessResult::exports, 0))?;
+
     class.define_method("comments", method!(ProcessResult::comments, 0))?;
+
     class.define_method("docstrings", method!(ProcessResult::docstrings, 0))?;
+
     class.define_method("symbols", method!(ProcessResult::symbols, 0))?;
+
     class.define_method("diagnostics", method!(ProcessResult::diagnostics, 0))?;
+
     class.define_method("chunks", method!(ProcessResult::chunks, 0))?;
 
     let class = module.define_class("FileMetrics", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(FileMetrics::new, -1))?;
+
     class.define_method("total_lines", method!(FileMetrics::total_lines, 0))?;
+
     class.define_method("code_lines", method!(FileMetrics::code_lines, 0))?;
+
     class.define_method("comment_lines", method!(FileMetrics::comment_lines, 0))?;
+
     class.define_method("blank_lines", method!(FileMetrics::blank_lines, 0))?;
+
     class.define_method("total_bytes", method!(FileMetrics::total_bytes, 0))?;
+
     class.define_method("node_count", method!(FileMetrics::node_count, 0))?;
+
     class.define_method("error_count", method!(FileMetrics::error_count, 0))?;
+
     class.define_method("max_depth", method!(FileMetrics::max_depth, 0))?;
 
     let class = module.define_class("StructureItem", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(StructureItem::new, -1))?;
+
     class.define_method("kind", method!(StructureItem::kind, 0))?;
+
     class.define_method("name", method!(StructureItem::name, 0))?;
+
     class.define_method("visibility", method!(StructureItem::visibility, 0))?;
+
     class.define_method("span", method!(StructureItem::span, 0))?;
+
     class.define_method("children", method!(StructureItem::children, 0))?;
+
     class.define_method("decorators", method!(StructureItem::decorators, 0))?;
+
     class.define_method("doc_comment", method!(StructureItem::doc_comment, 0))?;
+
     class.define_method("signature", method!(StructureItem::signature, 0))?;
+
     class.define_method("body_span", method!(StructureItem::body_span, 0))?;
 
     let class = module.define_class("CommentInfo", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(CommentInfo::new, -1))?;
+
     class.define_method("text", method!(CommentInfo::text, 0))?;
+
     class.define_method("kind", method!(CommentInfo::kind, 0))?;
+
     class.define_method("span", method!(CommentInfo::span, 0))?;
+
     class.define_method("associated_node", method!(CommentInfo::associated_node, 0))?;
 
     let class = module.define_class("DocstringInfo", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(DocstringInfo::new, -1))?;
+
     class.define_method("text", method!(DocstringInfo::text, 0))?;
+
     class.define_method("format", method!(DocstringInfo::format, 0))?;
+
     class.define_method("span", method!(DocstringInfo::span, 0))?;
+
     class.define_method("associated_item", method!(DocstringInfo::associated_item, 0))?;
+
     class.define_method("parsed_sections", method!(DocstringInfo::parsed_sections, 0))?;
 
     let class = module.define_class("DocSection", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(DocSection::new, -1))?;
+
     class.define_method("kind", method!(DocSection::kind, 0))?;
+
     class.define_method("name", method!(DocSection::name, 0))?;
+
     class.define_method("description", method!(DocSection::description, 0))?;
 
     let class = module.define_class("ImportInfo", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ImportInfo::new, -1))?;
+
     class.define_method("source", method!(ImportInfo::source, 0))?;
+
     class.define_method("items", method!(ImportInfo::items, 0))?;
+
     class.define_method("alias", method!(ImportInfo::alias, 0))?;
+
     class.define_method("is_wildcard", method!(ImportInfo::is_wildcard, 0))?;
+
     class.define_method("span", method!(ImportInfo::span, 0))?;
 
     let class = module.define_class("ExportInfo", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ExportInfo::new, -1))?;
+
     class.define_method("name", method!(ExportInfo::name, 0))?;
+
     class.define_method("kind", method!(ExportInfo::kind, 0))?;
+
     class.define_method("span", method!(ExportInfo::span, 0))?;
 
     let class = module.define_class("SymbolInfo", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(SymbolInfo::new, -1))?;
+
     class.define_method("name", method!(SymbolInfo::name, 0))?;
+
     class.define_method("kind", method!(SymbolInfo::kind, 0))?;
+
     class.define_method("span", method!(SymbolInfo::span, 0))?;
+
     class.define_method("type_annotation", method!(SymbolInfo::type_annotation, 0))?;
+
     class.define_method("doc", method!(SymbolInfo::doc, 0))?;
 
     let class = module.define_class("Diagnostic", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(Diagnostic::new, -1))?;
+
     class.define_method("message", method!(Diagnostic::message, 0))?;
+
     class.define_method("severity", method!(Diagnostic::severity, 0))?;
+
     class.define_method("span", method!(Diagnostic::span, 0))?;
 
     let class = module.define_class("CodeChunk", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(CodeChunk::new, -1))?;
+
     class.define_method("content", method!(CodeChunk::content, 0))?;
+
     class.define_method("start_byte", method!(CodeChunk::start_byte, 0))?;
+
     class.define_method("end_byte", method!(CodeChunk::end_byte, 0))?;
+
     class.define_method("start_line", method!(CodeChunk::start_line, 0))?;
+
     class.define_method("end_line", method!(CodeChunk::end_line, 0))?;
+
     class.define_method("metadata", method!(CodeChunk::metadata, 0))?;
+
     class.define_method("to_s", method!(CodeChunk::to_s, 0))?;
 
     let class = module.define_class("ChunkContext", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ChunkContext::new, -1))?;
+
     class.define_method("language", method!(ChunkContext::language, 0))?;
+
     class.define_method("chunk_index", method!(ChunkContext::chunk_index, 0))?;
+
     class.define_method("total_chunks", method!(ChunkContext::total_chunks, 0))?;
+
     class.define_method("node_types", method!(ChunkContext::node_types, 0))?;
+
     class.define_method("context_path", method!(ChunkContext::context_path, 0))?;
+
     class.define_method("symbols_defined", method!(ChunkContext::symbols_defined, 0))?;
+
     class.define_method("comments", method!(ChunkContext::comments, 0))?;
+
     class.define_method("docstrings", method!(ChunkContext::docstrings, 0))?;
+
     class.define_method("has_error_nodes", method!(ChunkContext::has_error_nodes, 0))?;
 
     let class = module.define_class("PackConfig", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(PackConfig::new, -1))?;
+
     class.define_method("cache_dir", method!(PackConfig::cache_dir, 0))?;
+
     class.define_method("languages", method!(PackConfig::languages, 0))?;
+
     class.define_method("groups", method!(PackConfig::groups, 0))?;
 
+    let class = module.define_class("Point", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(Point::new, -1))?;
+
+    class.define_method("row", method!(Point::row, 0))?;
+
+    class.define_method("column", method!(Point::column, 0))?;
+
+    let class = module.define_class("ByteRange", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(ByteRange::new, -1))?;
+
+    class.define_method("start", method!(ByteRange::start, 0))?;
+
+    class.define_method("end", method!(ByteRange::end, 0))?;
+
+    let class = module.define_class("Parser", ruby.class_object())?;
+
+    let class = module.define_class("Tree", ruby.class_object())?;
+
+    class.define_method("root_node", method!(Tree::root_node, 0))?;
+
+    class.define_method("walk", method!(Tree::walk, 0))?;
+
+    let class = module.define_class("Node", ruby.class_object())?;
+
+    class.define_method("clone", method!(Node::clone, 0))?;
+
+    class.define_method("kind", method!(Node::kind, 0))?;
+
+    class.define_method("kind_id", method!(Node::kind_id, 0))?;
+
+    class.define_method("start_byte", method!(Node::start_byte, 0))?;
+
+    class.define_method("end_byte", method!(Node::end_byte, 0))?;
+
+    class.define_method("byte_range", method!(Node::byte_range, 0))?;
+
+    class.define_method("start_position", method!(Node::start_position, 0))?;
+
+    class.define_method("end_position", method!(Node::end_position, 0))?;
+
+    class.define_method("is_named", method!(Node::is_named, 0))?;
+
+    class.define_method("is_error", method!(Node::is_error, 0))?;
+
+    class.define_method("is_missing", method!(Node::is_missing, 0))?;
+
+    class.define_method("is_extra", method!(Node::is_extra, 0))?;
+
+    class.define_method("has_error", method!(Node::has_error, 0))?;
+
+    class.define_method("parent", method!(Node::parent, 0))?;
+
+    class.define_method("child", method!(Node::child, 1))?;
+
+    class.define_method("child_count", method!(Node::child_count, 0))?;
+
+    class.define_method("named_child", method!(Node::named_child, 1))?;
+
+    class.define_method("named_child_count", method!(Node::named_child_count, 0))?;
+
+    class.define_method("child_by_field_name", method!(Node::child_by_field_name, 1))?;
+
+    class.define_method("to_sexp", method!(Node::to_sexp, 0))?;
+
+    class.define_method("walk", method!(Node::walk, 0))?;
+
+    let class = module.define_class("TreeCursor", ruby.class_object())?;
+
+    class.define_method("node", method!(TreeCursor::node, 0))?;
+
+    class.define_method("field_name", method!(TreeCursor::field_name, 0))?;
+
     let class = module.define_class("ProcessConfig", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ProcessConfig::new, -1))?;
+
     class.define_method("language", method!(ProcessConfig::language, 0))?;
+
     class.define_method("structure", method!(ProcessConfig::structure, 0))?;
+
     class.define_method("imports", method!(ProcessConfig::imports, 0))?;
+
     class.define_method("exports", method!(ProcessConfig::exports, 0))?;
+
     class.define_method("comments", method!(ProcessConfig::comments, 0))?;
+
     class.define_method("docstrings", method!(ProcessConfig::docstrings, 0))?;
+
     class.define_method("symbols", method!(ProcessConfig::symbols, 0))?;
+
     class.define_method("diagnostics", method!(ProcessConfig::diagnostics, 0))?;
+
     class.define_method("chunk_max_size", method!(ProcessConfig::chunk_max_size, 0))?;
+
     class.define_method("with_chunking", method!(ProcessConfig::with_chunking, 1))?;
+
     class.define_method("all", method!(ProcessConfig::all, 0))?;
+
     class.define_method("minimal", method!(ProcessConfig::minimal, 0))?;
 
     let class = module.define_class("LanguageRegistry", ruby.class_object())?;
+
     class.define_method("add_extra_libs_dir", method!(LanguageRegistry::add_extra_libs_dir, 1))?;
+
     class.define_method("get_language", method!(LanguageRegistry::get_language, 1))?;
+
     class.define_method("available_languages", method!(LanguageRegistry::available_languages, 0))?;
+
     class.define_method("has_language", method!(LanguageRegistry::has_language, 1))?;
+
     class.define_method("language_count", method!(LanguageRegistry::language_count, 0))?;
+
     class.define_method("process", method!(LanguageRegistry::process, 2))?;
 
     let class = module.define_class("ParserManifest", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ParserManifest::new, -1))?;
+
     class.define_method("version", method!(ParserManifest::version, 0))?;
+
     class.define_method("platforms", method!(ParserManifest::platforms, 0))?;
+
     class.define_method("languages", method!(ParserManifest::languages, 0))?;
+
     class.define_method("groups", method!(ParserManifest::groups, 0))?;
 
     let class = module.define_class("PlatformBundle", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(PlatformBundle::new, -1))?;
+
     class.define_method("url", method!(PlatformBundle::url, 0))?;
+
     class.define_method("sha256", method!(PlatformBundle::sha256, 0))?;
+
     class.define_method("size", method!(PlatformBundle::size, 0))?;
 
     let class = module.define_class("LanguageInfo", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(LanguageInfo::new, -1))?;
+
     class.define_method("group", method!(LanguageInfo::group, 0))?;
+
     class.define_method("size", method!(LanguageInfo::size, 0))?;
 
     let class = module.define_class("DownloadManager", ruby.class_object())?;
+
     class.define_method("cache_dir", method!(DownloadManager::cache_dir, 0))?;
+
     class.define_method("installed_languages", method!(DownloadManager::installed_languages, 0))?;
+
     class.define_method("ensure_languages", method!(DownloadManager::ensure_languages, 1))?;
+
     class.define_method("ensure_group", method!(DownloadManager::ensure_group, 1))?;
+
     class.define_method("lib_path", method!(DownloadManager::lib_path, 1))?;
+
     class.define_method("fetch_manifest", method!(DownloadManager::fetch_manifest, 0))?;
+
     class.define_method(
         "download_all_best_effort",
         method!(DownloadManager::download_all_best_effort, 0),
     )?;
+
     class.define_method("clean_cache", method!(DownloadManager::clean_cache, 0))?;
 
     let _class = module.define_class("Language", ruby.class_object())?;
 
-    let _class = module.define_class("Parser", ruby.class_object())?;
-
-    let _class = module.define_class("Tree", ruby.class_object())?;
-
     module.define_module_function(
         "detect_language_from_extension",
         function!(detect_language_from_extension, 1),
     )?;
+
     module.define_module_function("detect_language_from_path", function!(detect_language_from_path, 1))?;
+
     module.define_module_function(
         "detect_language_from_content",
         function!(detect_language_from_content, 1),
     )?;
+
     module.define_module_function("get_highlights_query", function!(get_highlights_query, 1))?;
+
     module.define_module_function("get_injections_query", function!(get_injections_query, 1))?;
+
     module.define_module_function("get_locals_query", function!(get_locals_query, 1))?;
+
     module.define_module_function("get_language", function!(get_language, 1))?;
+
     module.define_module_function("get_parser", function!(get_parser, 1))?;
+
     module.define_module_function("detect_language", function!(detect_language, 1))?;
+
     module.define_module_function("available_languages", function!(available_languages, 0))?;
+
     module.define_module_function("has_language", function!(has_language, 1))?;
+
     module.define_module_function("language_count", function!(language_count, 0))?;
+
     module.define_module_function("process", function!(process, -1))?;
+
     module.define_module_function("init", function!(init, -1))?;
+
     module.define_module_function("configure", function!(configure, -1))?;
+
     module.define_module_function("download", function!(download, 1))?;
+
     module.define_module_function("download_all", function!(download_all, 0))?;
+
     module.define_module_function("manifest_languages", function!(manifest_languages, 0))?;
+
     module.define_module_function("downloaded_languages", function!(downloaded_languages, 0))?;
+
     module.define_module_function("clean_cache", function!(clean_cache, 0))?;
+
     module.define_module_function("cache_dir", function!(cache_dir, 0))?;
 
     Ok(())