tree_sitter_language_pack 1.9.0.pre.rc.38 → 1.9.0.pre.rc.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11ff1558cce902704efbed4391e33e20a09a8e0a7941e0a8ddb2e80221edafe6
-  data.tar.gz: eb38284932ba04b60872f89ad3ed09e5eb5a835e8f3b7f5eef5b959ccc727da3
+  metadata.gz: 721c6c17cfb69a2f82454711ebde611ebe5c78831639f1dcd5b13620fdaf05be
+  data.tar.gz: 88a7b6611d48c00ad7df7c892c9d4d74862b29b2a05dbd014a0de9763e24e130
 SHA512:
-  metadata.gz: cbab5698da74c4b6e66fa88c4d7a788e5343649ab19f40c000ba4cf5c998645914499567fe0e1812f92601c627500400a3ea6e9abaa18d682e7818d3ddeeee00
-  data.tar.gz: a300a87951fc8fb89828f5321b975d259eb7363916a2c81fc1740e3e9c42b41953eac896f363692cfddd38afa61c1fdd2ec513805c51b5567041a038cdc1984f
+  metadata.gz: ab6d81352d22a0ea17e5cf0eadd906af9ed3d63f373f56125a57b768eacadfea018233069edb30ee61fd5e9dd38ac65d5db1b04399a381450226ca78d228cc37
+  data.tar.gz: f31ef2f67986bef22b207fc6f6ac62542433f9d6f3cdff06ee1493eb33055b20e8bf4cea0f64269affd6dc48ba09ce8d969997e5f588e09c3c06e6c4a24480e6

data/ext/ts_pack_core_rb/native/Cargo.lock

@@ -1070,9 +1070,9 @@ checksum = "009994f150cc0cd50ff54917d5bc8bffe8cad10ca10d81c34da2ec421ae61782"
 
 [[package]]
 name = "tree-sitter-language-pack"
-version = "1.9.0-rc.38"
+version = "1.9.0-rc.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dbb3d7e4f965ef6d07a41e663e190cb33c9d37eea2446834d19fb8b15f1e4fe"
+checksum = "8aa8e9c9e7756e0756aa0f2790db5dac1e89b454a0c39053af3cb78ef1285573"
 dependencies = [
  "ahash",
  "cc",
@@ -1093,7 +1093,7 @@ dependencies = [
 
 [[package]]
 name = "ts-pack-core-rb"
-version = "1.9.0-rc.38"
+version = "1.9.0-rc.39"
 dependencies = [
  "magnus",
  "rb-sys",

data/ext/ts_pack_core_rb/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ts-pack-core-rb"
-version = "1.9.0-rc.38"
+version = "1.9.0-rc.39"
 edition = "2024"
 license = "MIT"
 description = "Pre-compiled tree-sitter grammars for 306 programming languages"
@@ -21,4 +21,4 @@ magnus = "0.8"
 rb-sys = ">=0.9, <0.9.128"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-tree-sitter-language-pack = { version = "1.9.0-rc.38", features = ["serde", "config", "download"] }
+tree-sitter-language-pack = { version = "1.9.0-rc.39", features = ["serde", "config", "download"] }

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:5c3eac2ef7892df9942263b2ef22bbce08c4729cfb235dcd7f37f968755d1b10
+// alef:hash:966b101e2b4cacb4cb93c43f34e30e8bab6e2478b171704ec0a66561b9335a89
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -57,6 +57,194 @@ fn json_to_ruby(handle: &Ruby, val: serde_json::Value) -> magnus::Value {
     }
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::DataAttribute")]
+pub struct DataAttribute {
+    name: String,
+    value: String,
+    span: Span,
+}
+
+unsafe impl IntoValueFromNative for DataAttribute {}
+
+impl magnus::TryConvert for DataAttribute {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&DataAttribute 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 DataAttribute: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<DataAttribute>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize DataAttribute: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for DataAttribute {}
+
+impl Default for DataAttribute {
+    fn default() -> Self {
+        tree_sitter_language_pack::DataAttribute::default().into()
+    }
+}
+
+impl DataAttribute {
+    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(),
+            value: kwargs
+                .get(ruby.to_symbol("value"))
+                .and_then(|v| String::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 {
+        self.name.clone()
+    }
+
+    fn value(&self) -> String {
+        self.value.clone()
+    }
+
+    fn span(&self) -> Span {
+        self.span.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::DataNode")]
+pub struct DataNode {
+    kind: DataNodeKind,
+    key: Option<String>,
+    value: Option<String>,
+    attributes: Vec<DataAttribute>,
+    children: Vec<DataNode>,
+    span: Span,
+}
+
+unsafe impl IntoValueFromNative for DataNode {}
+
+impl magnus::TryConvert for DataNode {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&DataNode 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 DataNode: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<DataNode>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize DataNode: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for DataNode {}
+
+impl Default for DataNode {
+    fn default() -> Self {
+        Self {
+            kind: Default::default(),
+            key: None,
+            value: None,
+            attributes: vec![],
+            children: vec![],
+            span: Default::default(),
+        }
+    }
+}
+
+impl DataNode {
+    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| DataNodeKind::try_convert(v).ok())
+                .unwrap_or_default(),
+            key: kwargs
+                .get(ruby.to_symbol("key"))
+                .and_then(|v| String::try_convert(v).ok()),
+            value: kwargs
+                .get(ruby.to_symbol("value"))
+                .and_then(|v| String::try_convert(v).ok()),
+            attributes: kwargs
+                .get(ruby.to_symbol("attributes"))
+                .and_then(|v| <Vec<DataAttribute>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            children: kwargs
+                .get(ruby.to_symbol("children"))
+                .and_then(|v| <Vec<DataNode>>::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 kind(&self) -> DataNodeKind {
+        self.kind.clone()
+    }
+
+    fn key(&self) -> Option<String> {
+        self.key.clone()
+    }
+
+    fn value(&self) -> Option<String> {
+        self.value.clone()
+    }
+
+    fn attributes(&self) -> Vec<DataAttribute> {
+        self.attributes.clone()
+    }
+
+    fn children(&self) -> Vec<DataNode> {
+        self.children.clone()
+    }
+
+    fn span(&self) -> Span {
+        self.span.clone()
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::Span")]
@@ -176,6 +364,7 @@ pub struct ProcessResult {
     symbols: Vec<SymbolInfo>,
     diagnostics: Vec<Diagnostic>,
     chunks: Vec<CodeChunk>,
+    data: Option<DataNode>,
 }
 
 unsafe impl IntoValueFromNative for ProcessResult {}
@@ -259,6 +448,9 @@ impl ProcessResult {
                 .get(ruby.to_symbol("chunks"))
                 .and_then(|v| <Vec<CodeChunk>>::try_convert(v).ok())
                 .unwrap_or_default(),
+            data: kwargs
+                .get(ruby.to_symbol("data"))
+                .and_then(|v| DataNode::try_convert(v).ok()),
         })
     }
 
@@ -301,6 +493,10 @@ impl ProcessResult {
     fn chunks(&self) -> Vec<CodeChunk> {
         self.chunks.clone()
     }
+
+    fn data(&self) -> Option<DataNode> {
+        self.data.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -1875,6 +2071,7 @@ pub struct ProcessConfig {
     symbols: bool,
     diagnostics: bool,
     chunk_max_size: Option<usize>,
+    data_extraction: bool,
 }
 
 unsafe impl IntoValueFromNative for ProcessConfig {}
@@ -1953,6 +2150,10 @@ impl ProcessConfig {
             chunk_max_size: kwargs
                 .get(ruby.to_symbol("chunk_max_size"))
                 .and_then(|v| usize::try_convert(v).ok()),
+            data_extraction: kwargs
+                .get(ruby.to_symbol("data_extraction"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
         })
     }
 
@@ -1992,6 +2193,10 @@ impl ProcessConfig {
         self.chunk_max_size
     }
 
+    fn data_extraction(&self) -> bool {
+        self.data_extraction
+    }
+
     fn with_chunking(&self, max_size: usize) -> ProcessConfig {
         let core_self = tree_sitter_language_pack::ProcessConfig {
             language: self.language.clone().into(),
@@ -2011,6 +2216,8 @@ impl ProcessConfig {
             diagnostics: self.diagnostics,
 
             chunk_max_size: self.chunk_max_size,
+
+            data_extraction: self.data_extraction,
         };
         core_self.with_chunking(max_size).into()
     }
@@ -2034,6 +2241,8 @@ impl ProcessConfig {
             diagnostics: self.diagnostics,
 
             chunk_max_size: self.chunk_max_size,
+
+            data_extraction: self.data_extraction,
         };
         core_self.all().into()
     }
@@ -2057,9 +2266,36 @@ impl ProcessConfig {
             diagnostics: self.diagnostics,
 
             chunk_max_size: self.chunk_max_size,
+
+            data_extraction: self.data_extraction,
         };
         core_self.minimal().into()
     }
+
+    fn with_data_extraction(&self, enabled: bool) -> ProcessConfig {
+        let core_self = tree_sitter_language_pack::ProcessConfig {
+            language: self.language.clone().into(),
+
+            structure: self.structure,
+
+            imports: self.imports,
+
+            exports: self.exports,
+
+            comments: self.comments,
+
+            docstrings: self.docstrings,
+
+            symbols: self.symbols,
+
+            diagnostics: self.diagnostics,
+
+            chunk_max_size: self.chunk_max_size,
+
+            data_extraction: self.data_extraction,
+        };
+        core_self.with_data_extraction(enabled).into()
+    }
 }
 
 #[derive(Clone)]
@@ -2182,6 +2418,50 @@ unsafe impl TryConvertOwned for Language {}
 
 impl Language {}
 
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum DataNodeKind {
+    KeyValue,
+    Element,
+    Sequence,
+}
+
+impl Default for DataNodeKind {
+    fn default() -> Self {
+        Self::KeyValue
+    }
+}
+
+impl magnus::IntoValue for DataNodeKind {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            DataNodeKind::KeyValue => "key_value",
+            DataNodeKind::Element => "element",
+            DataNodeKind::Sequence => "sequence",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for DataNodeKind {
+    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() {
+            "key_value" | "KeyValue" => Ok(DataNodeKind::KeyValue),
+            "element" | "Element" => Ok(DataNodeKind::Element),
+            "sequence" | "Sequence" => Ok(DataNodeKind::Sequence),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid DataNodeKind value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for DataNodeKind {}
+unsafe impl TryConvertOwned for DataNodeKind {}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum StructureKind {
     Function,
@@ -2706,6 +2986,56 @@ fn cache_dir() -> Result<String, Error> {
     Ok(result)
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<DataAttribute> for tree_sitter_language_pack::DataAttribute {
+    fn from(val: DataAttribute) -> Self {
+        Self {
+            name: val.name,
+            value: val.value,
+            span: val.span.into(),
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<tree_sitter_language_pack::DataAttribute> for DataAttribute {
+    fn from(val: tree_sitter_language_pack::DataAttribute) -> Self {
+        Self {
+            name: val.name.to_string(),
+            value: val.value.to_string(),
+            span: val.span.into(),
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<DataNode> for tree_sitter_language_pack::DataNode {
+    fn from(val: DataNode) -> Self {
+        Self {
+            kind: val.kind.into(),
+            key: val.key,
+            value: val.value,
+            attributes: val.attributes.into_iter().map(Into::into).collect(),
+            children: val.children.into_iter().map(Into::into).collect(),
+            span: val.span.into(),
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<tree_sitter_language_pack::DataNode> for DataNode {
+    fn from(val: tree_sitter_language_pack::DataNode) -> Self {
+        Self {
+            kind: val.kind.into(),
+            key: val.key.map(|v| v.to_string()),
+            value: val.value.map(|v| v.to_string()),
+            attributes: val.attributes.into_iter().map(Into::into).collect(),
+            children: val.children.into_iter().map(Into::into).collect(),
+            span: val.span.into(),
+        }
+    }
+}
+
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<Span> for tree_sitter_language_pack::Span {
     fn from(val: Span) -> Self {
@@ -2748,6 +3078,7 @@ impl From<ProcessResult> for tree_sitter_language_pack::ProcessResult {
             symbols: val.symbols.into_iter().map(Into::into).collect(),
             diagnostics: val.diagnostics.into_iter().map(Into::into).collect(),
             chunks: val.chunks.into_iter().map(Into::into).collect(),
+            data: val.data.map(Into::into),
         }
     }
 }
@@ -2766,6 +3097,7 @@ impl From<tree_sitter_language_pack::ProcessResult> for ProcessResult {
             symbols: val.symbols.into_iter().map(Into::into).collect(),
             diagnostics: val.diagnostics.into_iter().map(Into::into).collect(),
             chunks: val.chunks.into_iter().map(Into::into).collect(),
+            data: val.data.map(Into::into),
         }
     }
 }
@@ -3141,6 +3473,7 @@ impl From<ProcessConfig> for tree_sitter_language_pack::ProcessConfig {
             symbols: val.symbols,
             diagnostics: val.diagnostics,
             chunk_max_size: val.chunk_max_size,
+            data_extraction: val.data_extraction,
         }
     }
 }
@@ -3158,6 +3491,27 @@ impl From<tree_sitter_language_pack::ProcessConfig> for ProcessConfig {
             symbols: val.symbols,
             diagnostics: val.diagnostics,
             chunk_max_size: val.chunk_max_size,
+            data_extraction: val.data_extraction,
+        }
+    }
+}
+
+impl From<DataNodeKind> for tree_sitter_language_pack::DataNodeKind {
+    fn from(val: DataNodeKind) -> Self {
+        match val {
+            DataNodeKind::KeyValue => Self::KeyValue,
+            DataNodeKind::Element => Self::Element,
+            DataNodeKind::Sequence => Self::Sequence,
+        }
+    }
+}
+
+impl From<tree_sitter_language_pack::DataNodeKind> for DataNodeKind {
+    fn from(val: tree_sitter_language_pack::DataNodeKind) -> Self {
+        match val {
+            tree_sitter_language_pack::DataNodeKind::KeyValue => Self::KeyValue,
+            tree_sitter_language_pack::DataNodeKind::Element => Self::Element,
+            tree_sitter_language_pack::DataNodeKind::Sequence => Self::Sequence,
         }
     }
 }
@@ -3330,6 +3684,32 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     // Ensure JSON library is loaded for Hash#to_json
     let _ = ruby.eval::<magnus::Value>("require \"json\"");
 
+    let class = module.define_class("DataAttribute", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(DataAttribute::new, -1))?;
+
+    class.define_method("name", method!(DataAttribute::name, 0))?;
+
+    class.define_method("value", method!(DataAttribute::value, 0))?;
+
+    class.define_method("span", method!(DataAttribute::span, 0))?;
+
+    let class = module.define_class("DataNode", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(DataNode::new, -1))?;
+
+    class.define_method("kind", method!(DataNode::kind, 0))?;
+
+    class.define_method("key", method!(DataNode::key, 0))?;
+
+    class.define_method("value", method!(DataNode::value, 0))?;
+
+    class.define_method("attributes", method!(DataNode::attributes, 0))?;
+
+    class.define_method("children", method!(DataNode::children, 0))?;
+
+    class.define_method("span", method!(DataNode::span, 0))?;
+
     let class = module.define_class("Span", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(Span::new, -1))?;
@@ -3370,6 +3750,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("chunks", method!(ProcessResult::chunks, 0))?;
 
+    class.define_method("data", method!(ProcessResult::data, 0))?;
+
     let class = module.define_class("FileMetrics", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(FileMetrics::new, -1))?;
@@ -3642,12 +4024,16 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("chunk_max_size", method!(ProcessConfig::chunk_max_size, 0))?;
 
+    class.define_method("data_extraction", method!(ProcessConfig::data_extraction, 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))?;
 
+    class.define_method("with_data_extraction", method!(ProcessConfig::with_data_extraction, 1))?;
+
     let class = module.define_class("LanguageRegistry", ruby.class_object())?;
 
     class.define_method("get_language", method!(LanguageRegistry::get_language, 1))?;

data/lib/tree_sitter_language_pack/native.rb

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:5c3eac2ef7892df9942263b2ef22bbce08c4729cfb235dcd7f37f968755d1b10
+# alef:hash:966b101e2b4cacb4cb93c43f34e30e8bab6e2478b171704ec0a66561b9335a89
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # frozen_string_literal: true

data/lib/tree_sitter_language_pack/version.rb

@@ -1,10 +1,10 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:af8fbb2b58d7d13bf4f1cf1965e5b0296b4767fb76d55cad9ec48420f80f2ff8
+# alef:hash:966b101e2b4cacb4cb93c43f34e30e8bab6e2478b171704ec0a66561b9335a89
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # frozen_string_literal: true
 
 module TreeSitterLanguagePack
   ## The version string for this package.
-  VERSION = "1.9.0.pre.rc.38"
+  VERSION = "1.9.0.pre.rc.39"
 end

data/lib/tree_sitter_language_pack.rb

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:5c3eac2ef7892df9942263b2ef22bbce08c4729cfb235dcd7f37f968755d1b10
+# alef:hash:966b101e2b4cacb4cb93c43f34e30e8bab6e2478b171704ec0a66561b9335a89
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # frozen_string_literal: true

data/sig/types.rbs

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:5c3eac2ef7892df9942263b2ef22bbce08c4729cfb235dcd7f37f968755d1b10
+# alef:hash:966b101e2b4cacb4cb93c43f34e30e8bab6e2478b171704ec0a66561b9335a89
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 
@@ -9,6 +9,25 @@ module TreeSitterLanguagePack
 
   type json_value = Hash[String, untyped] | Array[untyped] | String | Integer | Float | bool | nil
 
+  class DataAttribute
+    attr_accessor name: String?
+    attr_accessor value: String?
+    attr_accessor span: Span?
+
+    def initialize: (?name: String, ?value: String, ?span: Span) -> void
+  end
+
+  class DataNode
+    attr_accessor kind: DataNodeKind?
+    attr_accessor key: String?
+    attr_accessor value: String?
+    attr_accessor attributes: Array[DataAttribute]?
+    attr_accessor children: Array[DataNode]?
+    attr_accessor span: Span?
+
+    def initialize: (?kind: DataNodeKind, ?key: String, ?value: String, ?attributes: Array[DataAttribute], ?children: Array[DataNode], ?span: Span) -> void
+  end
+
   class Span
     attr_accessor start_byte: Integer?
     attr_accessor end_byte: Integer?
@@ -31,8 +50,9 @@ module TreeSitterLanguagePack
     attr_accessor symbols: Array[SymbolInfo]?
     attr_accessor diagnostics: Array[Diagnostic]?
     attr_accessor chunks: Array[CodeChunk]?
+    attr_accessor data: DataNode?
 
-    def initialize: (?language: String, ?metrics: FileMetrics, ?structure: Array[StructureItem], ?imports: Array[ImportInfo], ?exports: Array[ExportInfo], ?comments: Array[CommentInfo], ?docstrings: Array[DocstringInfo], ?symbols: Array[SymbolInfo], ?diagnostics: Array[Diagnostic], ?chunks: Array[CodeChunk]) -> void
+    def initialize: (?language: String, ?metrics: FileMetrics, ?structure: Array[StructureItem], ?imports: Array[ImportInfo], ?exports: Array[ExportInfo], ?comments: Array[CommentInfo], ?docstrings: Array[DocstringInfo], ?symbols: Array[SymbolInfo], ?diagnostics: Array[Diagnostic], ?chunks: Array[CodeChunk], ?data: DataNode) -> void
   end
 
   class FileMetrics
@@ -228,11 +248,13 @@ module TreeSitterLanguagePack
     attr_accessor symbols: bool?
     attr_accessor diagnostics: bool?
     attr_accessor chunk_max_size: Integer?
+    attr_accessor data_extraction: bool?
 
-    def initialize: (?language: String, ?structure: bool, ?imports: bool, ?exports: bool, ?comments: bool, ?docstrings: bool, ?symbols: bool, ?diagnostics: bool, ?chunk_max_size: Integer) -> void
+    def initialize: (?language: String, ?structure: bool, ?imports: bool, ?exports: bool, ?comments: bool, ?docstrings: bool, ?symbols: bool, ?diagnostics: bool, ?chunk_max_size: Integer, ?data_extraction: bool) -> void
     def with_chunking: (Integer max_size) -> ProcessConfig
     def all: () -> ProcessConfig
     def minimal: () -> ProcessConfig
+    def with_data_extraction: (bool enabled) -> ProcessConfig
     def self.default: () -> ProcessConfig
   end
 
@@ -257,6 +279,10 @@ module TreeSitterLanguagePack
   class Language
   end
 
+  class DataNodeKind
+    type value = :key_value | :element | :sequence
+  end
+
   class StructureKind
   end
 

metadata

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