tree_sitter_language_pack 1.8.0.pre.rc.43 → 1.8.0.pre.rc.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fff4426415d87ba46f03ce7fdb1a86ee51b3882ee6cf81e0bc2550c83e62f381
-  data.tar.gz: a602f644b1621faf5fd5347868d9fbe00433b217e1e8f77d67d96ed3e9e25003
+  metadata.gz: 2e37f5ecf12515b1edccf542a5c676a326a3898c5072cb3561a44e0262c132e6
+  data.tar.gz: 005ca96e301365661813588cdaa1cb951c6baf0ceee78df43c2ba2591e61c22e
 SHA512:
-  metadata.gz: 9d9407be51e44cec710301ff35e400e080845c067a9c11256f5dcfd55dd036ceff87108241ceac8daa3544f34cd6c044c2da64eebd29ec1a821c35c1e370e0b1
-  data.tar.gz: 942c8fc3b360689a0064d1ec41814303549707f93088940ae8b86a6f82179979ef7e81e8f3664a7d647d51caaf14fd6b17795dd0433ecb0abe3826a7d101e6a9
+  metadata.gz: 6b3a14f5677f663a0fae22f152ffae08af75379ebf8950fb017a9dd0874cf7a47211d765ecfee44f7fe695c915387d8b2ae780c00a4acba8f599ee6268c43900
+  data.tar.gz: e8c4d745a472388dbc574a553c050f099540be9db5863a98b7ed48b72cc76ac9d43cde4e495875aed85679bd4a5fe841080a96af08fa8d37c07ab78b7a38b6cc

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:133460f2380f225fd12d91c94096bfe370669a47766afaeffc5380fdbf0c3db7
+// alef:hash:eed307d857d74c9dce2d6a626941327b2f9e3442eaa781b0e2191b8f8b470855
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -96,34 +96,42 @@ unsafe impl TryConvertOwned for Span {}
 
 impl Default for Span {
     fn default() -> Self {
-        Self {
-            start_byte: Default::default(),
-            end_byte: Default::default(),
-            start_line: Default::default(),
-            start_column: Default::default(),
-            end_line: Default::default(),
-            end_column: Default::default(),
-        }
+        tree_sitter_language_pack::Span::default().into()
     }
 }
 
 impl Span {
-    fn new(
-        start_byte: usize,
-        end_byte: usize,
-        start_line: usize,
-        start_column: usize,
-        end_line: usize,
-        end_column: usize,
-    ) -> Self {
-        Self {
-            start_byte,
-            end_byte,
-            start_line,
-            start_column,
-            end_line,
-            end_column,
-        }
+    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_byte: kwargs
+                .get(ruby.to_symbol("start_byte"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            end_byte: kwargs
+                .get(ruby.to_symbol("end_byte"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            start_line: kwargs
+                .get(ruby.to_symbol("start_line"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            start_column: kwargs
+                .get(ruby.to_symbol("start_column"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            end_line: kwargs
+                .get(ruby.to_symbol("end_line"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            end_column: kwargs
+                .get(ruby.to_symbol("end_column"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn start_byte(&self) -> usize {
@@ -197,46 +205,58 @@ unsafe impl TryConvertOwned for ProcessResult {}
 
 impl Default for ProcessResult {
     fn default() -> Self {
-        Self {
-            language: Default::default(),
-            metrics: Default::default(),
-            structure: Default::default(),
-            imports: Default::default(),
-            exports: Default::default(),
-            comments: Default::default(),
-            docstrings: Default::default(),
-            symbols: Default::default(),
-            diagnostics: Default::default(),
-            chunks: Default::default(),
-        }
+        tree_sitter_language_pack::ProcessResult::default().into()
     }
 }
 
 impl ProcessResult {
-    fn new(
-        language: String,
-        metrics: FileMetrics,
-        structure: Vec<StructureItem>,
-        imports: Vec<ImportInfo>,
-        exports: Vec<ExportInfo>,
-        comments: Vec<CommentInfo>,
-        docstrings: Vec<DocstringInfo>,
-        symbols: Vec<SymbolInfo>,
-        diagnostics: Vec<Diagnostic>,
-        chunks: Vec<CodeChunk>,
-    ) -> Self {
-        Self {
-            language,
-            metrics,
-            structure,
-            imports,
-            exports,
-            comments,
-            docstrings,
-            symbols,
-            diagnostics,
-            chunks,
-        }
+    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 {
+            language: kwargs
+                .get(ruby.to_symbol("language"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            metrics: kwargs
+                .get(ruby.to_symbol("metrics"))
+                .and_then(|v| FileMetrics::try_convert(v).ok())
+                .unwrap_or_default(),
+            structure: kwargs
+                .get(ruby.to_symbol("structure"))
+                .and_then(|v| <Vec<StructureItem>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            imports: kwargs
+                .get(ruby.to_symbol("imports"))
+                .and_then(|v| <Vec<ImportInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            exports: kwargs
+                .get(ruby.to_symbol("exports"))
+                .and_then(|v| <Vec<ExportInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            comments: kwargs
+                .get(ruby.to_symbol("comments"))
+                .and_then(|v| <Vec<CommentInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            docstrings: kwargs
+                .get(ruby.to_symbol("docstrings"))
+                .and_then(|v| <Vec<DocstringInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            symbols: kwargs
+                .get(ruby.to_symbol("symbols"))
+                .and_then(|v| <Vec<SymbolInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            diagnostics: kwargs
+                .get(ruby.to_symbol("diagnostics"))
+                .and_then(|v| <Vec<Diagnostic>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            chunks: kwargs
+                .get(ruby.to_symbol("chunks"))
+                .and_then(|v| <Vec<CodeChunk>>::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn language(&self) -> String {
@@ -324,40 +344,50 @@ unsafe impl TryConvertOwned for FileMetrics {}
 
 impl Default for FileMetrics {
     fn default() -> Self {
-        Self {
-            total_lines: Default::default(),
-            code_lines: Default::default(),
-            comment_lines: Default::default(),
-            blank_lines: Default::default(),
-            total_bytes: Default::default(),
-            node_count: Default::default(),
-            error_count: Default::default(),
-            max_depth: Default::default(),
-        }
+        tree_sitter_language_pack::FileMetrics::default().into()
     }
 }
 
 impl FileMetrics {
-    fn new(
-        total_lines: usize,
-        code_lines: usize,
-        comment_lines: usize,
-        blank_lines: usize,
-        total_bytes: usize,
-        node_count: usize,
-        error_count: usize,
-        max_depth: usize,
-    ) -> Self {
-        Self {
-            total_lines,
-            code_lines,
-            comment_lines,
-            blank_lines,
-            total_bytes,
-            node_count,
-            error_count,
-            max_depth,
-        }
+    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 {
+            total_lines: kwargs
+                .get(ruby.to_symbol("total_lines"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            code_lines: kwargs
+                .get(ruby.to_symbol("code_lines"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            comment_lines: kwargs
+                .get(ruby.to_symbol("comment_lines"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            blank_lines: kwargs
+                .get(ruby.to_symbol("blank_lines"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            total_bytes: kwargs
+                .get(ruby.to_symbol("total_bytes"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            node_count: kwargs
+                .get(ruby.to_symbol("node_count"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            error_count: kwargs
+                .get(ruby.to_symbol("error_count"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            max_depth: kwargs
+                .get(ruby.to_symbol("max_depth"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn total_lines(&self) -> usize {
@@ -437,28 +467,44 @@ impl magnus::TryConvert for StructureItem {
 unsafe impl TryConvertOwned for StructureItem {}
 
 impl StructureItem {
-    fn new(
-        kind: StructureKind,
-        span: Span,
-        children: Vec<StructureItem>,
-        decorators: Vec<String>,
-        name: Option<String>,
-        visibility: Option<String>,
-        doc_comment: Option<String>,
-        signature: Option<String>,
-        body_span: Option<Span>,
-    ) -> Self {
-        Self {
-            kind,
-            name,
-            visibility,
-            span,
-            children,
-            decorators,
-            doc_comment,
-            signature,
-            body_span,
-        }
+    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 {
+            kind: kwargs
+                .get(ruby.to_symbol("kind"))
+                .and_then(|v| StructureKind::try_convert(v).ok())
+                .unwrap_or_default(),
+            name: kwargs
+                .get(ruby.to_symbol("name"))
+                .and_then(|v| String::try_convert(v).ok()),
+            visibility: kwargs
+                .get(ruby.to_symbol("visibility"))
+                .and_then(|v| String::try_convert(v).ok()),
+            span: kwargs
+                .get(ruby.to_symbol("span"))
+                .and_then(|v| Span::try_convert(v).ok())
+                .unwrap_or_default(),
+            children: kwargs
+                .get(ruby.to_symbol("children"))
+                .and_then(|v| <Vec<StructureItem>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            decorators: kwargs
+                .get(ruby.to_symbol("decorators"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            doc_comment: kwargs
+                .get(ruby.to_symbol("doc_comment"))
+                .and_then(|v| String::try_convert(v).ok()),
+            signature: kwargs
+                .get(ruby.to_symbol("signature"))
+                .and_then(|v| String::try_convert(v).ok()),
+            body_span: kwargs
+                .get(ruby.to_symbol("body_span"))
+                .and_then(|v| Span::try_convert(v).ok()),
+        })
     }
 
     fn kind(&self) -> StructureKind {
@@ -537,13 +583,28 @@ impl magnus::TryConvert for CommentInfo {
 unsafe impl TryConvertOwned for CommentInfo {}
 
 impl CommentInfo {
-    fn new(text: String, kind: CommentKind, span: Span, associated_node: Option<String>) -> Self {
-        Self {
-            text,
-            kind,
-            span,
-            associated_node,
-        }
+    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 {
+            text: kwargs
+                .get(ruby.to_symbol("text"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            kind: kwargs
+                .get(ruby.to_symbol("kind"))
+                .and_then(|v| CommentKind::try_convert(v).ok())
+                .unwrap_or_default(),
+            span: kwargs
+                .get(ruby.to_symbol("span"))
+                .and_then(|v| Span::try_convert(v).ok())
+                .unwrap_or_default(),
+            associated_node: kwargs
+                .get(ruby.to_symbol("associated_node"))
+                .and_then(|v| String::try_convert(v).ok()),
+        })
     }
 
     fn text(&self) -> String {
@@ -603,20 +664,32 @@ impl magnus::TryConvert for DocstringInfo {
 unsafe impl TryConvertOwned for DocstringInfo {}
 
 impl DocstringInfo {
-    fn new(
-        text: String,
-        format: DocstringFormat,
-        span: Span,
-        parsed_sections: Vec<DocSection>,
-        associated_item: Option<String>,
-    ) -> Self {
-        Self {
-            text,
-            format,
-            span,
-            associated_item,
-            parsed_sections,
-        }
+    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 {
+            text: kwargs
+                .get(ruby.to_symbol("text"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            format: kwargs
+                .get(ruby.to_symbol("format"))
+                .and_then(|v| DocstringFormat::try_convert(v).ok())
+                .unwrap_or_default(),
+            span: kwargs
+                .get(ruby.to_symbol("span"))
+                .and_then(|v| Span::try_convert(v).ok())
+                .unwrap_or_default(),
+            associated_item: kwargs
+                .get(ruby.to_symbol("associated_item"))
+                .and_then(|v| String::try_convert(v).ok()),
+            parsed_sections: kwargs
+                .get(ruby.to_symbol("parsed_sections"))
+                .and_then(|v| <Vec<DocSection>>::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn text(&self) -> String {
@@ -679,21 +752,29 @@ unsafe impl TryConvertOwned for DocSection {}
 
 impl Default for DocSection {
     fn default() -> Self {
-        Self {
-            kind: Default::default(),
-            name: Default::default(),
-            description: Default::default(),
-        }
+        tree_sitter_language_pack::DocSection::default().into()
     }
 }
 
 impl DocSection {
-    fn new(kind: String, description: String, name: Option<String>) -> Self {
-        Self {
-            kind,
-            name,
-            description,
-        }
+    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 {
+            kind: kwargs
+                .get(ruby.to_symbol("kind"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            name: kwargs
+                .get(ruby.to_symbol("name"))
+                .and_then(|v| String::try_convert(v).ok()),
+            description: kwargs
+                .get(ruby.to_symbol("description"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn kind(&self) -> String {
@@ -750,25 +831,37 @@ unsafe impl TryConvertOwned for ImportInfo {}
 
 impl Default for ImportInfo {
     fn default() -> Self {
-        Self {
-            source: Default::default(),
-            items: Default::default(),
-            alias: Default::default(),
-            is_wildcard: Default::default(),
-            span: Default::default(),
-        }
+        tree_sitter_language_pack::ImportInfo::default().into()
     }
 }
 
 impl ImportInfo {
-    fn new(source: String, items: Vec<String>, is_wildcard: bool, span: Span, alias: Option<String>) -> Self {
-        Self {
-            source,
-            items,
-            alias,
-            is_wildcard,
-            span,
-        }
+    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 {
+            source: kwargs
+                .get(ruby.to_symbol("source"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            items: kwargs
+                .get(ruby.to_symbol("items"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            alias: kwargs
+                .get(ruby.to_symbol("alias"))
+                .and_then(|v| String::try_convert(v).ok()),
+            is_wildcard: kwargs
+                .get(ruby.to_symbol("is_wildcard"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            span: kwargs
+                .get(ruby.to_symbol("span"))
+                .and_then(|v| Span::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn source(&self) -> String {
@@ -830,8 +923,25 @@ impl magnus::TryConvert for ExportInfo {
 unsafe impl TryConvertOwned for ExportInfo {}
 
 impl ExportInfo {
-    fn new(name: String, kind: ExportKind, span: Span) -> Self {
-        Self { name, kind, span }
+    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 {
+            name: kwargs
+                .get(ruby.to_symbol("name"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            kind: kwargs
+                .get(ruby.to_symbol("kind"))
+                .and_then(|v| ExportKind::try_convert(v).ok())
+                .unwrap_or_default(),
+            span: kwargs
+                .get(ruby.to_symbol("span"))
+                .and_then(|v| Span::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn name(&self) -> String {
@@ -887,14 +997,31 @@ impl magnus::TryConvert for SymbolInfo {
 unsafe impl TryConvertOwned for SymbolInfo {}
 
 impl SymbolInfo {
-    fn new(name: String, kind: SymbolKind, span: Span, type_annotation: Option<String>, doc: Option<String>) -> Self {
-        Self {
-            name,
-            kind,
-            span,
-            type_annotation,
-            doc,
-        }
+    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 {
+            name: kwargs
+                .get(ruby.to_symbol("name"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            kind: kwargs
+                .get(ruby.to_symbol("kind"))
+                .and_then(|v| SymbolKind::try_convert(v).ok())
+                .unwrap_or_default(),
+            span: kwargs
+                .get(ruby.to_symbol("span"))
+                .and_then(|v| Span::try_convert(v).ok())
+                .unwrap_or_default(),
+            type_annotation: kwargs
+                .get(ruby.to_symbol("type_annotation"))
+                .and_then(|v| String::try_convert(v).ok()),
+            doc: kwargs
+                .get(ruby.to_symbol("doc"))
+                .and_then(|v| String::try_convert(v).ok()),
+        })
     }
 
     fn name(&self) -> String {
@@ -956,12 +1083,25 @@ impl magnus::TryConvert for Diagnostic {
 unsafe impl TryConvertOwned for Diagnostic {}
 
 impl Diagnostic {
-    fn new(message: String, severity: DiagnosticSeverity, span: Span) -> Self {
-        Self {
-            message,
-            severity,
-            span,
-        }
+    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 {
+            message: kwargs
+                .get(ruby.to_symbol("message"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            severity: kwargs
+                .get(ruby.to_symbol("severity"))
+                .and_then(|v| DiagnosticSeverity::try_convert(v).ok())
+                .unwrap_or_default(),
+            span: kwargs
+                .get(ruby.to_symbol("span"))
+                .and_then(|v| Span::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn message(&self) -> String {
@@ -1019,34 +1159,42 @@ unsafe impl TryConvertOwned for CodeChunk {}
 
 impl Default for CodeChunk {
     fn default() -> Self {
-        Self {
-            content: Default::default(),
-            start_byte: Default::default(),
-            end_byte: Default::default(),
-            start_line: Default::default(),
-            end_line: Default::default(),
-            metadata: Default::default(),
-        }
+        tree_sitter_language_pack::CodeChunk::default().into()
     }
 }
 
 impl CodeChunk {
-    fn new(
-        content: String,
-        start_byte: usize,
-        end_byte: usize,
-        start_line: usize,
-        end_line: usize,
-        metadata: ChunkContext,
-    ) -> Self {
-        Self {
-            content,
-            start_byte,
-            end_byte,
-            start_line,
-            end_line,
-            metadata,
-        }
+    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 {
+            content: kwargs
+                .get(ruby.to_symbol("content"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            start_byte: kwargs
+                .get(ruby.to_symbol("start_byte"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            end_byte: kwargs
+                .get(ruby.to_symbol("end_byte"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            start_line: kwargs
+                .get(ruby.to_symbol("start_line"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            end_line: kwargs
+                .get(ruby.to_symbol("end_line"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            metadata: kwargs
+                .get(ruby.to_symbol("metadata"))
+                .and_then(|v| ChunkContext::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn content(&self) -> String {
@@ -1124,43 +1272,54 @@ unsafe impl TryConvertOwned for ChunkContext {}
 
 impl Default for ChunkContext {
     fn default() -> Self {
-        Self {
-            language: Default::default(),
-            chunk_index: Default::default(),
-            total_chunks: Default::default(),
-            node_types: Default::default(),
-            context_path: Default::default(),
-            symbols_defined: Default::default(),
-            comments: Default::default(),
-            docstrings: Default::default(),
-            has_error_nodes: Default::default(),
-        }
+        tree_sitter_language_pack::ChunkContext::default().into()
     }
 }
 
 impl ChunkContext {
-    fn new(
-        language: String,
-        chunk_index: usize,
-        total_chunks: usize,
-        node_types: Vec<String>,
-        context_path: Vec<String>,
-        symbols_defined: Vec<String>,
-        comments: Vec<CommentInfo>,
-        docstrings: Vec<DocstringInfo>,
-        has_error_nodes: bool,
-    ) -> Self {
-        Self {
-            language,
-            chunk_index,
-            total_chunks,
-            node_types,
-            context_path,
-            symbols_defined,
-            comments,
-            docstrings,
-            has_error_nodes,
-        }
+    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 {
+            language: kwargs
+                .get(ruby.to_symbol("language"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            chunk_index: kwargs
+                .get(ruby.to_symbol("chunk_index"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            total_chunks: kwargs
+                .get(ruby.to_symbol("total_chunks"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            node_types: kwargs
+                .get(ruby.to_symbol("node_types"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            context_path: kwargs
+                .get(ruby.to_symbol("context_path"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            symbols_defined: kwargs
+                .get(ruby.to_symbol("symbols_defined"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            comments: kwargs
+                .get(ruby.to_symbol("comments"))
+                .and_then(|v| <Vec<CommentInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            docstrings: kwargs
+                .get(ruby.to_symbol("docstrings"))
+                .and_then(|v| <Vec<DocstringInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            has_error_nodes: kwargs
+                .get(ruby.to_symbol("has_error_nodes"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn language(&self) -> String {
@@ -1239,21 +1398,27 @@ unsafe impl TryConvertOwned for PackConfig {}
 
 impl Default for PackConfig {
     fn default() -> Self {
-        Self {
-            cache_dir: Default::default(),
-            languages: Default::default(),
-            groups: Default::default(),
-        }
+        tree_sitter_language_pack::PackConfig::default().into()
     }
 }
 
 impl PackConfig {
-    fn new(cache_dir: Option<String>, languages: Option<Vec<String>>, groups: Option<Vec<String>>) -> Self {
-        Self {
-            cache_dir,
-            languages,
-            groups,
-        }
+    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 {
+            cache_dir: kwargs
+                .get(ruby.to_symbol("cache_dir"))
+                .and_then(|v| String::try_convert(v).ok()),
+            languages: kwargs
+                .get(ruby.to_symbol("languages"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok()),
+            groups: kwargs
+                .get(ruby.to_symbol("groups"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok()),
+        })
     }
 
     fn cache_dir(&self) -> Option<String> {
@@ -1314,43 +1479,53 @@ unsafe impl TryConvertOwned for ProcessConfig {}
 
 impl Default for ProcessConfig {
     fn default() -> Self {
-        Self {
-            language: Default::default(),
-            structure: Default::default(),
-            imports: Default::default(),
-            exports: Default::default(),
-            comments: Default::default(),
-            docstrings: Default::default(),
-            symbols: Default::default(),
-            diagnostics: Default::default(),
-            chunk_max_size: Default::default(),
-        }
+        tree_sitter_language_pack::ProcessConfig::default().into()
     }
 }
 
 impl ProcessConfig {
-    fn new(
-        language: String,
-        structure: bool,
-        imports: bool,
-        exports: bool,
-        comments: bool,
-        docstrings: bool,
-        symbols: bool,
-        diagnostics: bool,
-        chunk_max_size: Option<usize>,
-    ) -> Self {
-        Self {
-            language,
-            structure,
-            imports,
-            exports,
-            comments,
-            docstrings,
-            symbols,
-            diagnostics,
-            chunk_max_size,
-        }
+    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 {
+            language: kwargs
+                .get(ruby.to_symbol("language"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            structure: kwargs
+                .get(ruby.to_symbol("structure"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(true),
+            imports: kwargs
+                .get(ruby.to_symbol("imports"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(true),
+            exports: kwargs
+                .get(ruby.to_symbol("exports"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(true),
+            comments: kwargs
+                .get(ruby.to_symbol("comments"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            docstrings: kwargs
+                .get(ruby.to_symbol("docstrings"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            symbols: kwargs
+                .get(ruby.to_symbol("symbols"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            diagnostics: kwargs
+                .get(ruby.to_symbol("diagnostics"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            chunk_max_size: kwargs
+                .get(ruby.to_symbol("chunk_max_size"))
+                .and_then(|v| usize::try_convert(v).ok()),
+        })
     }
 
     fn language(&self) -> String {
@@ -1551,18 +1726,29 @@ impl magnus::TryConvert for ParserManifest {
 unsafe impl TryConvertOwned for ParserManifest {}
 
 impl ParserManifest {
-    fn new(
-        version: String,
-        platforms: HashMap<String, PlatformBundle>,
-        languages: HashMap<String, LanguageInfo>,
-        groups: HashMap<String, Vec<String>>,
-    ) -> Self {
-        Self {
-            version,
-            platforms,
-            languages,
-            groups,
-        }
+    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 {
+            version: kwargs
+                .get(ruby.to_symbol("version"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            platforms: kwargs
+                .get(ruby.to_symbol("platforms"))
+                .and_then(|v| <HashMap<String, PlatformBundle>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            languages: kwargs
+                .get(ruby.to_symbol("languages"))
+                .and_then(|v| <HashMap<String, LanguageInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            groups: kwargs
+                .get(ruby.to_symbol("groups"))
+                .and_then(|v| <HashMap<String, Vec<String>>>::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn version(&self) -> String {
@@ -1619,8 +1805,25 @@ impl magnus::TryConvert for PlatformBundle {
 unsafe impl TryConvertOwned for PlatformBundle {}
 
 impl PlatformBundle {
-    fn new(url: String, sha256: String, size: u64) -> Self {
-        Self { url, sha256, size }
+    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 {
+            url: kwargs
+                .get(ruby.to_symbol("url"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            sha256: kwargs
+                .get(ruby.to_symbol("sha256"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            size: kwargs
+                .get(ruby.to_symbol("size"))
+                .and_then(|v| u64::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn url(&self) -> String {
@@ -1672,8 +1875,21 @@ impl magnus::TryConvert for LanguageInfo {
 unsafe impl TryConvertOwned for LanguageInfo {}
 
 impl LanguageInfo {
-    fn new(group: String, size: u64) -> Self {
-        Self { group, size }
+    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 {
+            group: kwargs
+                .get(ruby.to_symbol("group"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            size: kwargs
+                .get(ruby.to_symbol("size"))
+                .and_then(|v| u64::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn group(&self) -> String {
@@ -1853,21 +2069,24 @@ impl magnus::IntoValue for StructureKind {
 impl magnus::TryConvert for StructureKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // If that fails, try treating it as a plain string value and wrap in quotes
+        // If both fail, try as Custom variant (for untagged enum support)
         serde_json::from_str(&s)
+            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+            .or_else(|_| {
+                // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
+                match serde_json::to_value(&s) {
+                    Ok(val) => serde_json::from_value(val),
+                    Err(e) => Err(e),
+                }
+            })
             .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))
     }
 }
 
 unsafe impl IntoValueFromNative for StructureKind {}
 unsafe impl TryConvertOwned for StructureKind {}
-impl StructureKind {
-    fn other(&self) -> Option<String> {
-        match self {
-            Self::Other { _0 } => Some(_0.clone()),
-            _ => None,
-        }
-    }
-}
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
 pub enum CommentKind {
@@ -1939,21 +2158,24 @@ impl magnus::IntoValue for DocstringFormat {
 impl magnus::TryConvert for DocstringFormat {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // If that fails, try treating it as a plain string value and wrap in quotes
+        // If both fail, try as Custom variant (for untagged enum support)
         serde_json::from_str(&s)
+            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+            .or_else(|_| {
+                // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
+                match serde_json::to_value(&s) {
+                    Ok(val) => serde_json::from_value(val),
+                    Err(e) => Err(e),
+                }
+            })
             .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))
     }
 }
 
 unsafe impl IntoValueFromNative for DocstringFormat {}
 unsafe impl TryConvertOwned for DocstringFormat {}
-impl DocstringFormat {
-    fn other(&self) -> Option<String> {
-        match self {
-            Self::Other { _0 } => Some(_0.clone()),
-            _ => None,
-        }
-    }
-}
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ExportKind {
@@ -2028,21 +2250,24 @@ impl magnus::IntoValue for SymbolKind {
 impl magnus::TryConvert for SymbolKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // If that fails, try treating it as a plain string value and wrap in quotes
+        // If both fail, try as Custom variant (for untagged enum support)
         serde_json::from_str(&s)
+            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+            .or_else(|_| {
+                // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
+                match serde_json::to_value(&s) {
+                    Ok(val) => serde_json::from_value(val),
+                    Err(e) => Err(e),
+                }
+            })
             .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))
     }
 }
 
 unsafe impl IntoValueFromNative for SymbolKind {}
 unsafe impl TryConvertOwned for SymbolKind {}
-impl SymbolKind {
-    fn other(&self) -> Option<String> {
-        match self {
-            Self::Other { _0 } => Some(_0.clone()),
-            _ => None,
-        }
-    }
-}
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
 pub enum DiagnosticSeverity {
@@ -2926,7 +3151,7 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("TreeSitterLanguagePack")?;
 
     let class = module.define_class("Span", ruby.class_object())?;
-    class.define_singleton_method("new", function!(Span::new, 6))?;
+    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))?;
@@ -2935,7 +3160,7 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     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, 10))?;
+    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))?;
@@ -2948,7 +3173,7 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     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, 8))?;
+    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))?;
@@ -2959,7 +3184,7 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     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, 9))?;
+    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))?;
@@ -2971,14 +3196,14 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     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, 4))?;
+    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, 5))?;
+    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))?;
@@ -2986,13 +3211,13 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     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, 3))?;
+    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, 5))?;
+    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))?;
@@ -3000,13 +3225,13 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     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, 3))?;
+    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, 5))?;
+    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))?;
@@ -3014,13 +3239,13 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     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, 3))?;
+    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, 6))?;
+    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))?;
@@ -3030,7 +3255,7 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     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, 9))?;
+    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))?;
@@ -3042,13 +3267,13 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     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, 3))?;
+    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("ProcessConfig", ruby.class_object())?;
-    class.define_singleton_method("new", function!(ProcessConfig::new, 9))?;
+    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))?;
@@ -3071,20 +3296,20 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     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, 4))?;
+    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, 3))?;
+    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, 2))?;
+    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))?;
 

data/ext/ts_pack_core_rb/src/tree_sitter_language_pack/version.rb

@@ -1,10 +1,10 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:67114fe2834308bdefd0e1ac878d8023d287cc5dba61baa6088e16c3c89e9cee
+# alef:hash:022d1f4e1fec514d50495a6cee0804bab2448e02fba38e81f5165a4c57b742bd
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # Issues & docs: https://github.com/kreuzberg-dev/alef
 # frozen_string_literal: true
 
 module Tree_sitter_language_pack
-  VERSION = '1.8.0.pre.rc.43'
+  VERSION = '1.8.0.pre.rc.44'
 end

data/lib/tree_sitter_language_pack/native.rb

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:b638543f033e039229fe860d8d3f9d16bb04a353217126d0401a975e2ecc3838
+# alef:hash:f1cee06ff8900ef2d958db4c1c0a5cb8d233243dfa3834f678c826f070dc817d
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # Issues & docs: https://github.com/kreuzberg-dev/alef
@@ -7,3 +7,40 @@
 
 require 'json'
 require 'ts_pack_core_rb'
+
+# Add accessor methods to Hash-based internally-tagged enum instances
+class Hash
+  # Support internally-tagged enum accessors like format.excel, format.email, etc.
+  # Also support direct field access like format.sheet_count
+  # rubocop:disable Metrics/CyclomaticComplexity
+  def method_missing(method_name, *args, &)
+    # Try symbol key first (how Magnus converts JSON keys)
+    return self[method_name] if key?(method_name)
+
+    # Try string key
+    return self[method_name.to_s] if key?(method_name.to_s)
+
+    # Check if this hash has a 'format_type' field (indicating an internally-tagged enum)
+    format_type = self[:format_type] || self['format_type']
+    return super unless format_type
+
+    # If the method name matches the format_type (snake_case), extract and return the variant's wrapped data
+    # Internally-tagged enums store variant data in the '_0' field (from alef's struct variant conversion)
+    # This allows format.excel to return the ExcelMetadata hash with sheet_count, sheet_names, etc.
+    snake_case_method = method_name.to_s.downcase
+    return self[:_0] || self['_0'] || self if snake_case_method == format_type.to_s.downcase
+
+    super
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity
+
+  def respond_to_missing?(method_name, include_private = false)
+    return true if key?(method_name) || key?(method_name.to_s)
+
+    format_type = self[:format_type] || self['format_type']
+    return false unless format_type
+
+    snake_case_method = method_name.to_s.downcase
+    snake_case_method == format_type.to_s.downcase || super
+  end
+end

data/lib/tree_sitter_language_pack/version.rb

@@ -1,10 +1,10 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:f72879f8162d8b8377bac9df171b35030472b294e5b4a9bf8d83a60edd7b6d45
+# alef:hash:e0342931f53b51d8116ea5c8a064e3acc1783cc8acd0d0fe337866407e99f370
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # Issues & docs: https://github.com/kreuzberg-dev/alef
 # frozen_string_literal: true
 
 module TreeSitterLanguagePack
-  VERSION = '1.8.0.pre.rc.43'
+  VERSION = '1.8.0.pre.rc.44'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tree_sitter_language_pack
 version: !ruby/object:Gem::Version
-  version: 1.8.0.pre.rc.43
+  version: 1.8.0.pre.rc.44
 platform: ruby
 authors:
 - Kreuzberg Team