yerba 0.9.2-arm-linux-gnu → 0.10.1-arm-linux-gnu

data/rust/src/yerbafile.rs

@@ -15,16 +15,51 @@ pub struct Yerbafile {
   pub rules: Vec<Rule>,
   #[serde(skip)]
   pub directory: Option<PathBuf>,
+  #[serde(skip)]
+  pub deprecated_path_keys: Vec<String>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct Rule {
   pub files: String,
+  #[serde(default, deserialize_with = "string_or_list")]
+  pub exclude: Vec<String>,
   #[serde(default)]
-  pub path: Option<String>,
+  #[serde(alias = "path")]
+  pub selector: Option<String>,
   pub pipeline: Vec<PipelineStep>,
 }
 
+impl Rule {
+  pub fn matches(&self, file: &str) -> bool {
+    matches_glob(&self.files, file) && !self.excludes(file)
+  }
+
+  pub fn excludes(&self, file: &str) -> bool {
+    self.exclude.iter().any(|pattern| matches_glob(pattern, file))
+  }
+}
+
+fn matches_glob(pattern: &str, file: &str) -> bool {
+  glob::Pattern::new(pattern)
+    .map(|pattern| pattern.matches(file) || pattern.matches_path(Path::new(file)))
+    .unwrap_or(false)
+}
+
+fn string_or_list<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Vec<String>, D::Error> {
+  #[derive(Deserialize)]
+  #[serde(untagged)]
+  enum StringOrList {
+    String(String),
+    List(Vec<String>),
+  }
+
+  Ok(match StringOrList::deserialize(deserializer)? {
+    StringOrList::String(string) => vec![string],
+    StringOrList::List(list) => list,
+  })
+}
+
 #[derive(Debug, Clone)]
 pub enum PipelineStep {
   SortKeys(SortKeysConfig),
@@ -48,17 +83,21 @@ pub enum PipelineStep {
 #[derive(Debug, Clone, Deserialize)]
 pub struct SortConfig {
   #[serde(default)]
-  pub path: Option<String>,
+  #[serde(alias = "path")]
+  pub selector: Option<String>,
   #[serde(default)]
   pub by: Option<String>,
   #[serde(default)]
   pub case_sensitive: bool,
+  #[serde(default)]
+  pub missing: Option<crate::SortMissing>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct BlankLinesConfig {
   #[serde(default)]
-  pub path: Option<String>,
+  #[serde(alias = "path")]
+  pub selector: Option<String>,
   pub count: usize,
   #[serde(default)]
   pub before: Vec<String>,
@@ -81,7 +120,8 @@ pub struct DirectivesConfig {
 #[derive(Debug, Clone, Deserialize)]
 pub struct UniqueConfig {
   #[serde(default)]
-  pub path: Option<String>,
+  #[serde(alias = "path")]
+  pub selector: Option<String>,
   #[serde(default = "default_dot")]
   pub by: String,
   #[serde(default)]
@@ -98,7 +138,8 @@ fn default_dot() -> String {
 pub struct SchemaConfig {
   pub file: String,
   #[serde(default)]
-  pub path: Option<String>,
+  #[serde(alias = "path")]
+  pub selector: Option<String>,
   #[serde(default)]
   pub items: bool,
 }
@@ -112,7 +153,8 @@ pub struct FinalNewlineConfig {
 #[derive(Debug, Clone, Deserialize)]
 pub struct EscapesConfig {
   #[serde(default)]
-  pub path: Option<String>,
+  #[serde(alias = "path")]
+  pub selector: Option<String>,
 }
 
 fn default_one() -> usize {
@@ -129,7 +171,8 @@ pub struct RenameConfig {
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct RemoveConfig {
-  pub path: String,
+  #[serde(alias = "path")]
+  pub selector: String,
   pub value: String,
   #[serde(default)]
   pub condition: Option<String>,
@@ -231,7 +274,8 @@ impl<'de> Deserialize<'de> for PipelineStep {
 #[derive(Debug, Clone, Deserialize)]
 pub struct SortKeysConfig {
   #[serde(default)]
-  pub path: Option<String>,
+  #[serde(alias = "path")]
+  pub selector: Option<String>,
   pub order: Vec<String>,
 }
 
@@ -241,26 +285,30 @@ pub struct QuoteStyleConfig {
   pub key_style: String,
   pub value_style: String,
   #[serde(default)]
-  pub path: Option<String>,
+  #[serde(alias = "path")]
+  pub selector: Option<String>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct CollectionStyleConfig {
   pub style: String,
   #[serde(default)]
-  pub path: Option<String>,
+  #[serde(alias = "path")]
+  pub selector: Option<String>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct SequenceIndentConfig {
   pub style: String,
   #[serde(default)]
-  pub path: Option<String>,
+  #[serde(alias = "path")]
+  pub selector: Option<String>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct SetConfig {
-  pub path: String,
+  #[serde(alias = "path")]
+  pub selector: String,
   pub value: String,
   #[serde(default)]
   pub condition: Option<String>,
@@ -270,7 +318,8 @@ pub struct SetConfig {
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct InsertConfig {
-  pub path: String,
+  #[serde(alias = "path")]
+  pub selector: String,
   pub value: String,
   #[serde(default)]
   pub condition: Option<String>,
@@ -280,7 +329,8 @@ pub struct InsertConfig {
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct DeleteConfig {
-  pub path: String,
+  #[serde(alias = "path")]
+  pub selector: String,
   #[serde(default)]
   pub condition: Option<String>,
 }
@@ -301,6 +351,7 @@ impl Yerbafile {
     let content = fs::read_to_string(path.as_ref())?;
     let mut yerbafile: Yerbafile = yaml_serde::from_str(&content).map_err(|error| YerbaError::ParseError(format!("{}", error)))?;
     yerbafile.directory = path.as_ref().parent().map(|p| p.to_path_buf());
+    yerbafile.deprecated_path_keys = deprecated_path_keys(&content);
     yerbafile.validate_conditions()?;
     Ok(yerbafile)
   }
@@ -359,7 +410,7 @@ impl Yerbafile {
     }
   }
 
-  pub fn sort_order_for(&self, file_path: &str, dot_path: &str) -> Option<Vec<String>> {
+  pub fn sort_order_for(&self, file_path: &str, selector: &str) -> Option<Vec<String>> {
     for rule in &self.rules {
       let sort_keys_config = rule.pipeline.iter().find_map(|step| match step {
         PipelineStep::SortKeys(config) => Some(config),
@@ -367,17 +418,15 @@ impl Yerbafile {
       });
 
       if let Some(config) = sort_keys_config {
-        let full_path = resolve_step_path(rule.path.as_deref(), config.path.as_deref());
-        let normalized = full_path.trim_end_matches("[]").trim_end_matches('.');
+        let full_selector = resolve_step_selector(rule.selector.as_deref(), config.selector.as_deref());
+        let normalized = full_selector.trim_end_matches("[]").trim_end_matches('.');
 
-        if normalized != dot_path && !normalized.is_empty() && !dot_path.is_empty() {
+        if normalized != selector && !normalized.is_empty() && !selector.is_empty() {
           continue;
         }
 
-        if let Ok(pattern) = glob::Pattern::new(&rule.files) {
-          if pattern.matches(file_path) || pattern.matches_path(Path::new(file_path)) {
-            return Some(config.order.clone());
-          }
+        if rule.matches(file_path) {
+          return Some(config.order.clone());
         }
       }
     }
@@ -404,7 +453,11 @@ impl Yerbafile {
         }
       };
 
-      let file_strings: Vec<String> = files.iter().map(|path| path.to_string_lossy().to_string()).collect();
+      let file_strings: Vec<String> = files
+        .iter()
+        .map(|path| path.to_string_lossy().to_string())
+        .filter(|file| !rule.excludes(file))
+        .collect();
 
       let file_results: Vec<RuleResult> = file_strings
         .par_iter()
@@ -472,10 +525,10 @@ impl Yerbafile {
       }
     }
 
-    let base_path = rule.path.as_deref();
+    let base_selector = rule.selector.as_deref();
 
     for step in &rule.pipeline {
-      if let Err(error) = execute_step(&mut document, step, base_path, file, self) {
+      if let Err(error) = execute_step(&mut document, step, base_selector, file, self) {
         return RuleResult {
           file: file.to_string(),
           changed: false,
@@ -509,11 +562,7 @@ impl Yerbafile {
     let mut ran_global = false;
 
     for rule in &self.rules {
-      if let Ok(pattern) = glob::Pattern::new(&rule.files) {
-        if !pattern.matches(file) && !pattern.matches_path(Path::new(file)) {
-          continue;
-        }
-      } else {
+      if !rule.matches(file) {
         continue;
       }
 
@@ -625,20 +674,14 @@ impl Yerbafile {
     }
 
     for rule in &self.rules {
-      if !match_path.is_empty() {
-        if let Ok(pattern) = glob::Pattern::new(&rule.files) {
-          if !pattern.matches(match_path) && !pattern.matches_path(Path::new(match_path)) {
-            continue;
-          }
-        } else {
-          continue;
-        }
+      if !match_path.is_empty() && !rule.matches(match_path) {
+        continue;
       }
 
-      let base_path = rule.path.as_deref();
+      let base_selector = rule.selector.as_deref();
 
       for step in &rule.pipeline {
-        execute_step(document, step, base_path, file_path, self)?;
+        execute_step(document, step, base_selector, file_path, self)?;
       }
     }
 
@@ -652,7 +695,7 @@ fn control_character_error(source: &str) -> Option<YerbaError> {
   (!found.is_empty()).then_some(YerbaError::ControlCharacters(found))
 }
 
-fn execute_pipeline(document: &mut Document, steps: &[PipelineStep], base_path: Option<&str>, file: &str, yerbafile: &Yerbafile) -> Result<(), YerbaError> {
+fn execute_pipeline(document: &mut Document, steps: &[PipelineStep], base_selector: Option<&str>, file: &str, yerbafile: &Yerbafile) -> Result<(), YerbaError> {
   use crate::document::style::StyleEnforcement;
 
   let mut enforcement = StyleEnforcement {
@@ -667,17 +710,17 @@ fn execute_pipeline(document: &mut Document, steps: &[PipelineStep], base_path:
 
   for step in steps {
     match step {
-      PipelineStep::CollectionStyle(config) if config.path.is_none() && base_path.is_none() => {
+      PipelineStep::CollectionStyle(config) if config.selector.is_none() && base_selector.is_none() => {
         enforcement.collection_style = Some(config.style.clone());
         has_enforcement = true;
       }
 
-      PipelineStep::SequenceIndent(config) if config.path.is_none() && base_path.is_none() => {
+      PipelineStep::SequenceIndent(config) if config.selector.is_none() && base_selector.is_none() => {
         enforcement.sequence_indent = Some(config.style.clone());
         has_enforcement = true;
       }
 
-      PipelineStep::QuoteStyle(config) if config.path.is_none() && base_path.is_none() => {
+      PipelineStep::QuoteStyle(config) if config.selector.is_none() && base_selector.is_none() => {
         let key_style = config.key_style.parse::<crate::KeyStyle>().ok();
         let value_style = config.value_style.parse::<QuoteStyle>().ok();
 
@@ -695,23 +738,23 @@ fn execute_pipeline(document: &mut Document, steps: &[PipelineStep], base_path:
   }
 
   for step in remaining_steps {
-    execute_step(document, step, base_path, file, yerbafile)?;
+    execute_step(document, step, base_selector, file, yerbafile)?;
   }
 
   Ok(())
 }
 
-fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<&str>, _file: &str, yerbafile: &Yerbafile) -> Result<(), YerbaError> {
+fn execute_step(document: &mut Document, step: &PipelineStep, base_selector: Option<&str>, _file: &str, yerbafile: &Yerbafile) -> Result<(), YerbaError> {
   match step {
     PipelineStep::QuoteStyle(config) => {
-      let dot_path = config.path.as_deref();
+      let selector = config.selector.as_deref();
 
       let key_style = config.key_style.parse::<crate::KeyStyle>().map_err(YerbaError::ParseError)?;
 
       let value_style = config.value_style.parse::<QuoteStyle>().map_err(YerbaError::ParseError)?;
 
-      document.enforce_key_style(&key_style, dot_path)?;
-      let warnings = document.enforce_quotes_at(&value_style, dot_path)?;
+      document.enforce_key_style(&key_style, selector)?;
+      let warnings = document.enforce_quotes_at(&value_style, selector)?;
 
       for warning in &warnings {
         eprintln!("  warning: {}", warning);
@@ -721,52 +764,52 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
     }
 
     PipelineStep::CollectionStyle(config) => {
-      let dot_path = resolve_step_path(base_path, config.path.as_deref());
-      let path = if dot_path.is_empty() { None } else { Some(dot_path.as_str()) };
+      let selector = resolve_step_selector(base_selector, config.selector.as_deref());
+      let path = if selector.is_empty() { None } else { Some(selector.as_str()) };
 
       document.enforce_collection_style(&config.style, path)
     }
 
     PipelineStep::SequenceIndent(config) => {
-      let dot_path = resolve_step_path(base_path, config.path.as_deref());
-      let path = if dot_path.is_empty() { None } else { Some(dot_path.as_str()) };
+      let selector = resolve_step_selector(base_selector, config.selector.as_deref());
+      let path = if selector.is_empty() { None } else { Some(selector.as_str()) };
 
       document.enforce_sequence_indent(&config.style, path)
     }
 
     PipelineStep::SortKeys(config) => {
-      let full_path = resolve_step_path(base_path, config.path.as_deref());
+      let full_selector = resolve_step_selector(base_selector, config.selector.as_deref());
       let key_order: Vec<&str> = config.order.iter().map(|key| key.as_str()).collect();
 
-      document.validate_sort_keys(&full_path, &key_order)?;
-      document.sort_keys(&full_path, &key_order)
+      document.validate_sort_keys(&full_selector, &key_order)?;
+      document.sort_keys(&full_selector, &key_order)
     }
 
     PipelineStep::Set(config) => {
-      let full_path = resolve_step_path(base_path, Some(&config.path));
+      let full_selector = resolve_step_selector(base_selector, Some(&config.selector));
 
       if let Some(condition) = &config.condition {
-        let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+        let parent_selector = full_selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-        if !document.evaluate_condition(parent_path, condition)? {
+        if !document.evaluate_condition(parent_selector, condition)? {
           return Ok(());
         }
       }
 
       if config.plain {
-        document.set_plain(&full_path, &config.value)
+        document.set_plain(&full_selector, &config.value)
       } else {
-        document.set(&full_path, &config.value)
+        document.set(&full_selector, &config.value)
       }
     }
 
     PipelineStep::Insert(config) => {
-      let full_path = resolve_step_path(base_path, Some(&config.path));
+      let full_selector = resolve_step_selector(base_selector, Some(&config.selector));
 
       if let Some(condition) = &config.condition {
-        let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+        let parent_selector = full_selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-        if !document.evaluate_condition(parent_path, condition)? {
+        if !document.evaluate_condition(parent_selector, condition)? {
           return Ok(());
         }
       }
@@ -777,20 +820,20 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
         crate::syntax::quote_scalar(&config.value)
       };
 
-      document.insert_into(&full_path, &value, crate::InsertPosition::Last)
+      document.insert_into(&full_selector, &value, crate::InsertPosition::Last)
     }
 
     PipelineStep::Delete(config) => {
-      let full_path = resolve_step_path(base_path, Some(&config.path));
+      let full_selector = resolve_step_selector(base_selector, Some(&config.selector));
 
-      if full_path.contains("[]") {
-        let concrete_selectors = document.resolve_selectors(&full_path);
+      if full_selector.contains("[]") {
+        let concrete_selectors = document.resolve_selectors(&full_selector);
 
         for selector in concrete_selectors.into_iter().rev() {
           if let Some(condition) = &config.condition {
-            let parent_path = selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+            let parent_selector = selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-            if !document.evaluate_condition(parent_path, condition)? {
+            if !document.evaluate_condition(parent_selector, condition)? {
               continue;
             }
           }
@@ -801,47 +844,47 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
         Ok(())
       } else {
         if let Some(condition) = &config.condition {
-          let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+          let parent_selector = full_selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-          if !document.evaluate_condition(parent_path, condition)? {
+          if !document.evaluate_condition(parent_selector, condition)? {
             return Ok(());
           }
         }
 
-        document.delete(&full_path)
+        document.delete(&full_selector)
       }
     }
 
     PipelineStep::Rename(config) => {
-      let full_path = resolve_step_path(base_path, Some(&config.from));
+      let full_selector = resolve_step_selector(base_selector, Some(&config.from));
 
       if let Some(condition) = &config.condition {
-        let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+        let parent_selector = full_selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-        if !document.evaluate_condition(parent_path, condition)? {
+        if !document.evaluate_condition(parent_selector, condition)? {
           return Ok(());
         }
       }
 
-      document.rename(&full_path, &config.to)
+      document.rename(&full_selector, &config.to)
     }
 
     PipelineStep::Remove(config) => {
-      let full_path = resolve_step_path(base_path, Some(&config.path));
+      let full_selector = resolve_step_selector(base_selector, Some(&config.selector));
 
       if let Some(condition) = &config.condition {
-        let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+        let parent_selector = full_selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-        if !document.evaluate_condition(parent_path, condition)? {
+        if !document.evaluate_condition(parent_selector, condition)? {
           return Ok(());
         }
       }
 
-      document.remove(&full_path, &config.value)
+      document.remove(&full_selector, &config.value)
     }
 
     PipelineStep::BlankLines(config) => {
-      let full_path = resolve_step_path(base_path, config.path.as_deref());
+      let full_selector = resolve_step_selector(base_selector, config.selector.as_deref());
 
       let options = crate::BlankLineOptions {
         before: config.before.clone(),
@@ -849,14 +892,14 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
         skip_empty: config.skip_empty,
       };
 
-      document.enforce_blank_lines_with(&full_path, config.count, &options)
+      document.enforce_blank_lines_with(&full_selector, config.count, &options)
     }
 
     PipelineStep::Sort(config) => {
-      let full_path = resolve_step_path(base_path, config.path.as_deref());
+      let full_selector = resolve_step_selector(base_selector, config.selector.as_deref());
       let sort_fields = config.by.as_deref().map(crate::SortField::parse_list).unwrap_or_default();
 
-      document.sort_items(&full_path, &sort_fields, config.case_sensitive)
+      document.sort_items_with(&full_selector, &sort_fields, config.case_sensitive, config.missing)
     }
 
     PipelineStep::Directives(config) => {
@@ -868,7 +911,7 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
         let locations = document.directive_locations();
 
         if locations.len() > max {
-          let positions: Vec<String> = locations.iter().map(|(line, col)| format!("{}:{}", line, col)).collect();
+          let positions: Vec<String> = locations.iter().map(|(line, column)| format!("{}:{}", line, column + 1)).collect();
 
           return Err(YerbaError::ParseError(format!(
             "found {} directive markers (---) at {}, expected at most {}",
@@ -891,7 +934,7 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
     PipelineStep::Schema(config) => {
       let schema_path = yerbafile.resolve_path(&config.file);
       let schema = crate::schema::load_schema(&schema_path)?;
-      let selector = resolve_step_path(base_path, config.path.as_deref());
+      let selector = resolve_step_selector(base_selector, config.selector.as_deref());
       let errors = document.validate_schema(&schema, config.items, if selector.is_empty() { None } else { Some(&selector) });
 
       if errors.is_empty() {
@@ -902,8 +945,8 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
     }
 
     PipelineStep::Unique(config) => {
-      let full_path = resolve_step_path(base_path, config.path.as_deref());
-      let duplicates = document.unique_with_options(&full_path, &config.by, config.remove, config.allow_blank_duplicates)?;
+      let full_selector = resolve_step_selector(base_selector, config.selector.as_deref());
+      let duplicates = document.unique_with_options(&full_selector, &config.by, config.remove, config.allow_blank_duplicates)?;
 
       if !duplicates.is_empty() && !config.remove {
         return Err(YerbaError::DuplicateValues(duplicates));
@@ -915,17 +958,17 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
     PipelineStep::FinalNewline(config) => document.enforce_final_newline(config.count),
 
     PipelineStep::Escapes(config) => {
-      let full_path = resolve_step_path(base_path, config.path.as_deref());
-      let scope = if full_path.is_empty() { None } else { Some(full_path.as_str()) };
+      let full_selector = resolve_step_selector(base_selector, config.selector.as_deref());
+      let scope = if full_selector.is_empty() { None } else { Some(full_selector.as_str()) };
 
       document.decode_escapes(scope).map(|_| ())
     }
   }
 }
 
-fn resolve_step_path(base_path: Option<&str>, step_path: Option<&str>) -> String {
-  let base = base_path.unwrap_or("");
-  let step = step_path.unwrap_or("");
+fn resolve_step_selector(base_selector: Option<&str>, step_selector: Option<&str>) -> String {
+  let base = base_selector.unwrap_or("");
+  let step = step_selector.unwrap_or("");
 
   match (base.is_empty(), step.is_empty()) {
     (true, true) => String::new(),
@@ -934,3 +977,34 @@ fn resolve_step_path(base_path: Option<&str>, step_path: Option<&str>) -> String
     (false, false) => format!("{}.{}", base, step),
   }
 }
+
+// TODO(v1.0): remove together with the `path` aliases on the rule and step configs.
+fn deprecated_path_keys(content: &str) -> Vec<String> {
+  let Ok(yerbafile) = yaml_serde::from_str::<yaml_serde::Value>(content) else {
+    return Vec::new();
+  };
+
+  let mut found = Vec::new();
+
+  let check_pipeline = |pipeline: Option<&yaml_serde::Value>, prefix: &str, found: &mut Vec<String>| {
+    for (index, step) in pipeline.and_then(|pipeline| pipeline.as_sequence()).into_iter().flatten().enumerate() {
+      for (name, config) in step.as_mapping().into_iter().flatten() {
+        if config.get("path").is_some() {
+          found.push(format!("{}pipeline[{}].{}", prefix, index, name.as_str().unwrap_or_default()));
+        }
+      }
+    }
+  };
+
+  check_pipeline(yerbafile.get("pipeline"), "", &mut found);
+
+  for (index, rule) in yerbafile.get("rules").and_then(|rules| rules.as_sequence()).into_iter().flatten().enumerate() {
+    if rule.get("path").is_some() {
+      found.push(format!("rules[{}]", index));
+    }
+
+    check_pipeline(rule.get("pipeline"), &format!("rules[{}].", index), &mut found);
+  }
+
+  found
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.1
 platform: arm-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-13 00:00:00.000000000 Z
+date: 2026-10-14 00:00:00.000000000 Z
 dependencies: []
 description: A CLI tool for editing YAML while preserving structure, comments, and
   format.
@@ -78,6 +78,7 @@ files:
 - rust/src/document/get.rs
 - rust/src/document/insert.rs
 - rust/src/document/mod.rs
+- rust/src/document/nodes.rs
 - rust/src/document/schema.rs
 - rust/src/document/set.rs
 - rust/src/document/sort.rs