tree_sitter_language_pack 1.8.1 → 1.9.0.pre.rc.2

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:2b779fd4a6411cbf6f73ed90dc178998e48f73f245c189530e77b9cad8d334d5
+// alef:hash:a73f3f13c65d02941aef62a37b9b2051ea03b9a31b9017f47182d51888d6138e
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -20,7 +20,6 @@
 )]
 
 use magnus::{Error, IntoValueFromNative, Ruby, function, method, prelude::*, try_convert::TryConvertOwned};
-use std::collections::HashMap;
 use std::sync::Arc;
 use std::sync::Mutex;
 
@@ -2081,10 +2080,6 @@ impl magnus::TryConvert for LanguageRegistry {
 unsafe impl TryConvertOwned for LanguageRegistry {}
 
 impl LanguageRegistry {
-    fn add_extra_libs_dir(&self, dir: String) -> () {
-        self.inner.add_extra_libs_dir(std::path::PathBuf::from(dir))
-    }
-
     fn get_language(&self, name: String) -> Result<Language, Error> {
         let result = self.inner.get_language(&name).map_err(|e| {
             magnus::Error::new(
@@ -2121,219 +2116,6 @@ impl LanguageRegistry {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::ParserManifest")]
-pub struct ParserManifest {
-    version: String,
-    platforms: HashMap<String, PlatformBundle>,
-    languages: HashMap<String, LanguageInfo>,
-    groups: HashMap<String, Vec<String>>,
-}
-
-unsafe impl IntoValueFromNative for ParserManifest {}
-
-impl magnus::TryConvert for ParserManifest {
-    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        if let Ok(r) = <&ParserManifest 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 ParserManifest: {}", e),
-                )
-            })?
-        };
-        serde_json::from_str::<ParserManifest>(&json_str).map_err(|e| {
-            magnus::Error::new(
-                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                format!("failed to deserialize ParserManifest: {}", e),
-            )
-        })
-    }
-}
-
-unsafe impl TryConvertOwned for ParserManifest {}
-
-impl ParserManifest {
-    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 {
-        self.version.clone()
-    }
-
-    fn platforms(&self) -> HashMap<String, PlatformBundle> {
-        self.platforms.clone()
-    }
-
-    fn languages(&self) -> HashMap<String, LanguageInfo> {
-        self.languages.clone()
-    }
-
-    fn groups(&self) -> HashMap<String, Vec<String>> {
-        self.groups.clone()
-    }
-}
-
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::PlatformBundle")]
-pub struct PlatformBundle {
-    url: String,
-    sha256: String,
-    size: u64,
-}
-
-unsafe impl IntoValueFromNative for PlatformBundle {}
-
-impl magnus::TryConvert for PlatformBundle {
-    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        if let Ok(r) = <&PlatformBundle 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 PlatformBundle: {}", e),
-                )
-            })?
-        };
-        serde_json::from_str::<PlatformBundle>(&json_str).map_err(|e| {
-            magnus::Error::new(
-                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                format!("failed to deserialize PlatformBundle: {}", e),
-            )
-        })
-    }
-}
-
-unsafe impl TryConvertOwned for PlatformBundle {}
-
-impl PlatformBundle {
-    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 {
-        self.url.clone()
-    }
-
-    fn sha256(&self) -> String {
-        self.sha256.clone()
-    }
-
-    fn size(&self) -> u64 {
-        self.size
-    }
-}
-
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::LanguageInfo")]
-pub struct LanguageInfo {
-    group: String,
-    size: u64,
-}
-
-unsafe impl IntoValueFromNative for LanguageInfo {}
-
-impl magnus::TryConvert for LanguageInfo {
-    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        if let Ok(r) = <&LanguageInfo 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 LanguageInfo: {}", e),
-                )
-            })?
-        };
-        serde_json::from_str::<LanguageInfo>(&json_str).map_err(|e| {
-            magnus::Error::new(
-                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                format!("failed to deserialize LanguageInfo: {}", e),
-            )
-        })
-    }
-}
-
-unsafe impl TryConvertOwned for LanguageInfo {}
-
-impl LanguageInfo {
-    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 {
-        self.group.clone()
-    }
-
-    fn size(&self) -> u64 {
-        self.size
-    }
-}
-
 #[derive(Clone)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::DownloadManager")]
 pub struct DownloadManager {
@@ -2352,49 +2134,10 @@ impl magnus::TryConvert for DownloadManager {
 unsafe impl TryConvertOwned for DownloadManager {}
 
 impl DownloadManager {
-    fn cache_dir(&self) -> String {
-        self.inner.cache_dir().to_string_lossy().to_string()
-    }
-
     fn installed_languages(&self) -> Vec<String> {
         self.inner.installed_languages()
     }
 
-    fn ensure_languages(&self, names: Vec<String>) -> Result<(), Error> {
-        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> {
-        self.inner.ensure_group(&group).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
-        Ok(())
-    }
-
-    fn lib_path(&self, name: String) -> String {
-        self.inner.lib_path(&name).to_string_lossy().to_string()
-    }
-
-    fn fetch_manifest(&self) -> Result<ParserManifest, Error> {
-        let result = self.inner.fetch_manifest().map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
-        Ok(result.into())
-    }
-
     fn download_all_best_effort(&self) -> Result<usize, Error> {
         let result = self.inner.download_all_best_effort().map_err(|e| {
             magnus::Error::new(
@@ -2467,15 +2210,26 @@ 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\"")
+        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // For unit enums or when passed as a string, fall back to string-based conversion.
+        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 { Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into StructureKind: {}", e),
+                )
+            })?
+        };
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"" or "{\"click\":{\"selector\":\"...\"}}\"")
         // 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}\"")))
+        serde_json::from_str(&json_str)
+            .or_else(|_| serde_json::from_str(&format!("\"{json_str}\"")))
             .or_else(|_| {
                 // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
-                match serde_json::to_value(&s) {
+                match serde_json::to_value(&json_str) {
                     Ok(val) => serde_json::from_value(val),
                     Err(e) => Err(e),
                 }
@@ -2558,15 +2312,26 @@ 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\"")
+        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // For unit enums or when passed as a string, fall back to string-based conversion.
+        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 { Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into DocstringFormat: {}", e),
+                )
+            })?
+        };
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"" or "{\"click\":{\"selector\":\"...\"}}\"")
         // 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}\"")))
+        serde_json::from_str(&json_str)
+            .or_else(|_| serde_json::from_str(&format!("\"{json_str}\"")))
             .or_else(|_| {
                 // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
-                match serde_json::to_value(&s) {
+                match serde_json::to_value(&json_str) {
                     Ok(val) => serde_json::from_value(val),
                     Err(e) => Err(e),
                 }
@@ -2652,15 +2417,26 @@ 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\"")
+        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // For unit enums or when passed as a string, fall back to string-based conversion.
+        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 { Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into SymbolKind: {}", e),
+                )
+            })?
+        };
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"" or "{\"click\":{\"selector\":\"...\"}}\"")
         // 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}\"")))
+        serde_json::from_str(&json_str)
+            .or_else(|_| serde_json::from_str(&format!("\"{json_str}\"")))
             .or_else(|_| {
                 // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
-                match serde_json::to_value(&s) {
+                match serde_json::to_value(&json_str) {
                     Ok(val) => serde_json::from_value(val),
                     Err(e) => Err(e),
                 }
@@ -2878,6 +2654,16 @@ fn download_all() -> Result<usize, Error> {
     Ok(result)
 }
 
+fn download_group(name: String) -> Result<usize, Error> {
+    let result = tree_sitter_language_pack::download_group(&name).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(result)
+}
+
 fn manifest_languages() -> Result<Vec<String>, Error> {
     let result = tree_sitter_language_pack::manifest_languages().map_err(|e| {
         magnus::Error::new(
@@ -3017,7 +2803,7 @@ impl From<StructureItem> for tree_sitter_language_pack::StructureItem {
             visibility: val.visibility,
             span: val.span.into(),
             children: val.children.into_iter().map(Into::into).collect(),
-            decorators: val.decorators,
+            decorators: val.decorators.into_iter().collect(),
             doc_comment: val.doc_comment,
             signature: val.signature,
             body_span: val.body_span.map(Into::into),
@@ -3034,7 +2820,7 @@ impl From<tree_sitter_language_pack::StructureItem> for StructureItem {
             visibility: val.visibility,
             span: val.span.into(),
             children: val.children.into_iter().map(Into::into).collect(),
-            decorators: val.decorators,
+            decorators: val.decorators.into_iter().collect(),
             doc_comment: val.doc_comment,
             signature: val.signature,
             body_span: val.body_span.map(Into::into),
@@ -3119,7 +2905,7 @@ impl From<ImportInfo> for tree_sitter_language_pack::ImportInfo {
     fn from(val: ImportInfo) -> Self {
         Self {
             source: val.source,
-            items: val.items,
+            items: val.items.into_iter().collect(),
             alias: val.alias,
             is_wildcard: val.is_wildcard,
             span: val.span.into(),
@@ -3132,7 +2918,7 @@ impl From<tree_sitter_language_pack::ImportInfo> for ImportInfo {
     fn from(val: tree_sitter_language_pack::ImportInfo) -> Self {
         Self {
             source: val.source,
-            items: val.items,
+            items: val.items.into_iter().collect(),
             alias: val.alias,
             is_wildcard: val.is_wildcard,
             span: val.span.into(),
@@ -3245,9 +3031,9 @@ impl From<ChunkContext> for tree_sitter_language_pack::ChunkContext {
             language: val.language,
             chunk_index: val.chunk_index,
             total_chunks: val.total_chunks,
-            node_types: val.node_types,
-            context_path: val.context_path,
-            symbols_defined: val.symbols_defined,
+            node_types: val.node_types.into_iter().collect(),
+            context_path: val.context_path.into_iter().collect(),
+            symbols_defined: val.symbols_defined.into_iter().collect(),
             comments: val.comments.into_iter().map(Into::into).collect(),
             docstrings: val.docstrings.into_iter().map(Into::into).collect(),
             has_error_nodes: val.has_error_nodes,
@@ -3262,9 +3048,9 @@ impl From<tree_sitter_language_pack::ChunkContext> for ChunkContext {
             language: val.language,
             chunk_index: val.chunk_index,
             total_chunks: val.total_chunks,
-            node_types: val.node_types,
-            context_path: val.context_path,
-            symbols_defined: val.symbols_defined,
+            node_types: val.node_types.into_iter().collect(),
+            context_path: val.context_path.into_iter().collect(),
+            symbols_defined: val.symbols_defined.into_iter().collect(),
             comments: val.comments.into_iter().map(Into::into).collect(),
             docstrings: val.docstrings.into_iter().map(Into::into).collect(),
             has_error_nodes: val.has_error_nodes,
@@ -3277,8 +3063,8 @@ impl From<PackConfig> for tree_sitter_language_pack::PackConfig {
     fn from(val: PackConfig) -> Self {
         Self {
             cache_dir: val.cache_dir.map(Into::into),
-            languages: val.languages,
-            groups: val.groups,
+            languages: val.languages.map(|v| v.into_iter().collect()),
+            groups: val.groups.map(|v| v.into_iter().collect()),
         }
     }
 }
@@ -3288,8 +3074,8 @@ impl From<tree_sitter_language_pack::PackConfig> for PackConfig {
     fn from(val: tree_sitter_language_pack::PackConfig) -> Self {
         Self {
             cache_dir: val.cache_dir.map(|p| p.to_string_lossy().to_string()),
-            languages: val.languages,
-            groups: val.groups,
+            languages: val.languages.map(|v| v.into_iter().collect()),
+            groups: val.groups.map(|v| v.into_iter().collect()),
         }
     }
 }
@@ -3368,72 +3154,6 @@ impl From<tree_sitter_language_pack::ProcessConfig> for ProcessConfig {
     }
 }
 
-#[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<ParserManifest> for tree_sitter_language_pack::download::ParserManifest {
-    fn from(val: ParserManifest) -> Self {
-        Self {
-            version: val.version,
-            platforms: val.platforms.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
-            languages: val.languages.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
-            groups: val.groups.into_iter().collect(),
-        }
-    }
-}
-
-#[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<tree_sitter_language_pack::download::ParserManifest> for ParserManifest {
-    fn from(val: tree_sitter_language_pack::download::ParserManifest) -> Self {
-        Self {
-            version: val.version,
-            platforms: val.platforms.into_iter().map(|(k, v)| (k, v.into())).collect(),
-            languages: val.languages.into_iter().map(|(k, v)| (k, v.into())).collect(),
-            groups: val.groups.into_iter().collect(),
-        }
-    }
-}
-
-#[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<PlatformBundle> for tree_sitter_language_pack::download::PlatformBundle {
-    fn from(val: PlatformBundle) -> Self {
-        Self {
-            url: val.url,
-            sha256: val.sha256,
-            size: val.size,
-        }
-    }
-}
-
-#[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<tree_sitter_language_pack::download::PlatformBundle> for PlatformBundle {
-    fn from(val: tree_sitter_language_pack::download::PlatformBundle) -> Self {
-        Self {
-            url: val.url,
-            sha256: val.sha256,
-            size: val.size,
-        }
-    }
-}
-
-#[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<LanguageInfo> for tree_sitter_language_pack::download::LanguageInfo {
-    fn from(val: LanguageInfo) -> Self {
-        Self {
-            group: val.group,
-            size: val.size,
-        }
-    }
-}
-
-#[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<tree_sitter_language_pack::download::LanguageInfo> for LanguageInfo {
-    fn from(val: tree_sitter_language_pack::download::LanguageInfo) -> Self {
-        Self {
-            group: val.group,
-            size: val.size,
-        }
-    }
-}
-
 impl From<StructureKind> for tree_sitter_language_pack::StructureKind {
     fn from(val: StructureKind) -> Self {
         match val {
@@ -3922,8 +3642,6 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     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))?;
@@ -3934,50 +3652,10 @@ 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, -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),
@@ -4027,6 +3705,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     module.define_module_function("download_all", function!(download_all, 0))?;
 
+    module.define_module_function("download_group", function!(download_group, 1))?;
+
     module.define_module_function("manifest_languages", function!(manifest_languages, 0))?;
 
     module.define_module_function("downloaded_languages", function!(downloaded_languages, 0))?;

data/lib/tree_sitter_language_pack/native.rb

@@ -1,46 +1,10 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:8b6fde19410058828311dde84042fe181eb3e1d609f3f53d64b4f7127db9e6af
+# alef:hash:7c2ad6574f6e1041a85475b2fb60302a621b00af3af9ae49ceacb610d7676405
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # Issues & docs: https://github.com/kreuzberg-dev/alef
 # frozen_string_literal: true
 
 require 'json'
+require 'sorbet-runtime'
 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