yerba 0.5.0-x86_64-linux-gnu → 0.5.1-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 497a769ee07b1e766ff7e0f991212be8268e475d1e5a9cc882e9f62845390401
-  data.tar.gz: d7e66c881d9547477d3ea8ebc232e52141a561a063179cf3534ad9c0090e1ad2
+  metadata.gz: 19b6906bd8f2db29860e1dfe1cb78a80d26b8cfa30ce01a9b76de7be22568a0c
+  data.tar.gz: 618eea79126aa8456337d0c3a905dd0d782510457b16bb368fa70e1de4177df3
 SHA512:
-  metadata.gz: 5fc61b863455ba54bb41f63da74d32114e62cc54c2f467534ce6da158b3c8ef820defe227de73179f8b013b9ec4d1824ca8c850f7538f7d0305b215c944d2279
-  data.tar.gz: 6d6a96b09dc0536f5704e43da759b75c0404d60c89d7ec6691bc1d3313d7f9ac0cfa755836de18dfcf224a57ca42f0afdfb19303a661ee3fc3c8b0e19d20f3a1
+  metadata.gz: a49b141053cd6cc9e6803a914a9d4cd443e376b59319e5484b2c9bf139b245c7bf7be888739d179e5fb14dcd7931f95e878d1430ebd2694c25354d08fe5625ed
+  data.tar.gz: 959d1cd010d792c74b4ad0d45c815e30b3b76fd5becb7d78a1c64736ded4e41b08c8e2049f7e79912c7675f2c479656f868180b0567388a9c1864a41639f8f18

data/README.md

@@ -47,7 +47,7 @@ Use `yerba` as a library in your Rust project:
 
 ```toml
 [dependencies]
-yerba = "0.4"
+yerba = "0.5"
 ```
 
 ```rust

data/lib/yerba/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yerba
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/rust/Cargo.lock

@@ -739,6 +739,12 @@ version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
+[[package]]
+name = "libyaml-rs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e126dda6f34391ab7b444f9922055facc83c07a910da3eb16f1e4d9c45dc777"
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.12.1"
@@ -1198,19 +1204,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "serde_yaml"
-version = "0.9.34+deprecated"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
-dependencies = [
- "indexmap",
- "itoa",
- "ryu",
- "serde",
- "unsafe-libyaml",
-]
-
 [[package]]
 name = "slab"
 version = "0.4.12"
@@ -1441,12 +1434,6 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
-[[package]]
-name = "unsafe-libyaml"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
-
 [[package]]
 name = "url"
 version = "2.5.8"
@@ -1770,9 +1757,22 @@ dependencies = [
  "winnow",
 ]
 
+[[package]]
+name = "yaml_serde"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08c7c1b1a6a7c8a6b2741a6c21a4f8918e51899b111cfa08d1288202656e3975"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "libyaml-rs",
+ "ryu",
+ "serde",
+]
+
 [[package]]
 name = "yerba"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "cbindgen",
  "clap",
@@ -1783,9 +1783,9 @@ dependencies = [
  "rowan",
  "serde",
  "serde_json",
- "serde_yaml",
  "tempfile",
  "yaml_parser",
+ "yaml_serde",
 ]
 
 [[package]]

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"
@@ -24,7 +24,7 @@ yaml_parser = "0.3"
 rowan = "0.16"
 glob = "0.3"
 serde = { version = "1", features = ["derive"] }
-serde_yaml = "0.9"
+yaml_serde = "0.10"
 serde_json = { version = "1", features = ["preserve_order"] }
 clap = { version = "4", features = ["derive"] }
 indoc = "2"

data/rust/src/commands/get.rs

@@ -112,7 +112,7 @@ impl Args {
         }
       }
 
-      let (values, selectors, lines): (Vec<serde_yaml::Value>, Vec<String>, Vec<usize>) = if select_fields.is_some() {
+      let (values, selectors, lines): (Vec<yaml_serde::Value>, Vec<String>, Vec<usize>) = if select_fields.is_some() {
         if let Some(condition) = &normalized_condition {
           let triples = document.filter_with_selectors(&search_path_string, condition);
           let (values, rest): (Vec<_>, Vec<_>) = triples.into_iter().map(|(v, s, l)| (v, (s, l))).unzip();

data/rust/src/commands/selectors.rs

@@ -116,11 +116,11 @@ impl Args {
   }
 }
 
-fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mut BTreeMap<String, SelectorInfo>, counter: &mut usize) {
+fn collect_selectors(value: &yaml_serde::Value, prefix: &str, selectors: &mut BTreeMap<String, SelectorInfo>, counter: &mut usize) {
   match value {
-    serde_yaml::Value::Mapping(map) => {
+    yaml_serde::Value::Mapping(map) => {
       for (key, child) in map {
-        if let serde_yaml::Value::String(key_string) = key {
+        if let yaml_serde::Value::String(key_string) = key {
           let selector = if prefix.is_empty() {
             key_string.clone()
           } else {
@@ -138,7 +138,7 @@ fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mut BT
       }
     }
 
-    serde_yaml::Value::Sequence(sequence) => {
+    yaml_serde::Value::Sequence(sequence) => {
       let bracket_prefix = format!("{}[]", prefix);
 
       let entry = selectors.entry(bracket_prefix.clone()).or_default();

data/rust/src/commands/sort.rs

@@ -329,7 +329,7 @@ impl Args {
       .map(|item| {
         if by_is_scalar {
           match item {
-            serde_yaml::Value::String(string) => string.clone(),
+            yaml_serde::Value::String(string) => string.clone(),
             _ => serde_json::to_string(&yerba::json::yaml_to_json(item)).unwrap_or_default(),
           }
         } else {

data/rust/src/document/condition.rs

@@ -1,7 +1,7 @@
 use super::*;
 
 impl Document {
-  pub fn filter(&self, dot_path: &str, condition: &str) -> Vec<serde_yaml::Value> {
+  pub fn filter(&self, dot_path: &str, condition: &str) -> Vec<yaml_serde::Value> {
     self
       .navigate_all_compact(dot_path)
       .iter()
@@ -10,7 +10,7 @@ impl Document {
       .collect()
   }
 
-  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Vec<(serde_yaml::Value, String, usize)> {
+  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Vec<(yaml_serde::Value, String, usize)> {
     let source = self.root.text().to_string();
 
     self

data/rust/src/document/delete.rs

@@ -35,17 +35,61 @@ impl Document {
   pub fn delete(&mut self, dot_path: &str) -> Result<(), YerbaError> {
     Self::validate_path(dot_path)?;
 
-    let (parent_path, last_key) = dot_path.rsplit_once('.').unwrap_or(("", dot_path));
-    let parent_node = self.navigate(parent_path)?;
+    let selector = crate::selector::Selector::parse(dot_path);
+    let segments = selector.segments();
+    let last_segment = segments.last().ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let parent_path = selector.parent_path();
 
-    let map = parent_node
-      .descendants()
-      .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    match last_segment {
+      crate::selector::SelectorSegment::Key(last_key) => {
+        let has_wildcard = selector.has_wildcard() || selector.has_brackets();
+        let parent_nodes = self.navigate_all_compact(&parent_path);
+
+        if parent_nodes.is_empty() {
+          if has_wildcard {
+            return Ok(());
+          }
+
+          return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
+        }
+
+        if parent_nodes.len() == 1 && !has_wildcard {
+          let map = parent_nodes[0]
+            .descendants()
+            .find_map(BlockMap::cast)
+            .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+          let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+          return self.remove_node(entry.syntax());
+        }
 
-    let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+        let mut ranges: Vec<TextRange> = Vec::new();
 
-    self.remove_node(entry.syntax())
+        for parent_node in &parent_nodes {
+          if let Some(map) = parent_node.descendants().find_map(BlockMap::cast) {
+            if let Some(entry) = find_entry_by_key(&map, last_key) {
+              ranges.push(removal_range(entry.syntax()));
+            }
+          }
+        }
+
+        if ranges.is_empty() {
+          return Ok(());
+        }
+
+        ranges.reverse();
+
+        for range in ranges {
+          self.apply_edit(range, "")?;
+        }
+
+        Ok(())
+      }
+
+      crate::selector::SelectorSegment::Index(index) => self.remove_at(&parent_path, *index),
+      crate::selector::SelectorSegment::AllItems => Err(YerbaError::SelectorNotFound(dot_path.to_string())),
+    }
   }
 
   pub fn remove(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {

data/rust/src/document/get.rs

@@ -278,7 +278,7 @@ impl Document {
       .collect()
   }
 
-  pub fn get_value(&self, dot_path: &str) -> Option<serde_yaml::Value> {
+  pub fn get_value(&self, dot_path: &str) -> Option<yaml_serde::Value> {
     if dot_path.is_empty() {
       return Some(node_to_yaml_value(&self.root));
     }
@@ -292,15 +292,15 @@ impl Document {
         return None;
       }
 
-      let values: Vec<serde_yaml::Value> = padded
+      let values: Vec<yaml_serde::Value> = padded
         .iter()
         .map(|maybe_node| match maybe_node {
           Some(node) => node_to_yaml_value(node),
-          None => serde_yaml::Value::Null,
+          None => yaml_serde::Value::Null,
         })
         .collect();
 
-      Some(serde_yaml::Value::Sequence(values))
+      Some(yaml_serde::Value::Sequence(values))
     } else {
       let nodes = self.navigate_all_compact(dot_path);
 
@@ -312,13 +312,13 @@ impl Document {
         return Some(node_to_yaml_value(&nodes[0]));
       }
 
-      let values: Vec<serde_yaml::Value> = nodes.iter().map(node_to_yaml_value).collect();
+      let values: Vec<yaml_serde::Value> = nodes.iter().map(node_to_yaml_value).collect();
 
-      Some(serde_yaml::Value::Sequence(values))
+      Some(yaml_serde::Value::Sequence(values))
     }
   }
 
-  pub fn get_values(&self, dot_path: &str) -> Vec<serde_yaml::Value> {
+  pub fn get_values(&self, dot_path: &str) -> Vec<yaml_serde::Value> {
     let parsed = crate::selector::Selector::parse(dot_path);
 
     if parsed.has_wildcard() {
@@ -327,7 +327,7 @@ impl Document {
         .iter()
         .map(|maybe_node| match maybe_node {
           Some(node) => node_to_yaml_value(node),
-          None => serde_yaml::Value::Null,
+          None => yaml_serde::Value::Null,
         })
         .collect()
     } else {

data/rust/src/document/insert.rs

@@ -22,9 +22,9 @@ impl Document {
       }
     }
 
-    if let Some(serde_yaml::Value::Sequence(sequence)) = self.get_value(dot_path).as_ref() {
-      if let Some(serde_yaml::Value::Mapping(map)) = sequence.first() {
-        if let Some((serde_yaml::Value::String(key_name), _)) = map.iter().next() {
+    if let Some(yaml_serde::Value::Sequence(sequence)) = self.get_value(dot_path).as_ref() {
+      if let Some(yaml_serde::Value::Mapping(map)) = sequence.first() {
+        if let Some((yaml_serde::Value::String(key_name), _)) = map.iter().next() {
           let deep_path = if dot_path.is_empty() {
             format!("[].{}", key_name)
           } else {

data/rust/src/document/mod.rs

@@ -445,11 +445,11 @@ pub(crate) fn compute_location(source: &str, start_offset: usize, end_offset: us
   }
 }
 
-pub fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mut Vec<String>) {
+pub fn collect_selectors(value: &yaml_serde::Value, prefix: &str, selectors: &mut Vec<String>) {
   match value {
-    serde_yaml::Value::Mapping(map) => {
+    yaml_serde::Value::Mapping(map) => {
       for (key, child) in map {
-        if let serde_yaml::Value::String(key_string) = key {
+        if let yaml_serde::Value::String(key_string) = key {
           let selector = if prefix.is_empty() {
             key_string.clone()
           } else {
@@ -462,7 +462,7 @@ pub fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mu
       }
     }
 
-    serde_yaml::Value::Sequence(sequence) => {
+    yaml_serde::Value::Sequence(sequence) => {
       let bracket_prefix = format!("{}[]", prefix);
       selectors.push(bracket_prefix.clone());
 
@@ -475,21 +475,21 @@ pub fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mu
   }
 }
 
-pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::Value {
+pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> yaml_serde::Value {
   if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
     let map_position = node.descendants().find_map(BlockMap::cast).map(|map| map.syntax().text_range().start());
 
     let sequence_position = sequence.syntax().text_range().start();
 
     if map_position.is_none() || sequence_position <= map_position.unwrap() {
-      let values: Vec<serde_yaml::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
+      let values: Vec<yaml_serde::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
 
-      return serde_yaml::Value::Sequence(values);
+      return yaml_serde::Value::Sequence(values);
     }
   }
 
   if let Some(map) = node.descendants().find_map(BlockMap::cast) {
-    let mut mapping = serde_yaml::Mapping::new();
+    let mut mapping = yaml_serde::Mapping::new();
 
     for entry in map.entries() {
       let key = entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())).unwrap_or_default();
@@ -497,18 +497,18 @@ pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::Value {
       let value = entry
         .value()
         .map(|value_node| node_to_yaml_value(value_node.syntax()))
-        .unwrap_or(serde_yaml::Value::Null);
+        .unwrap_or(yaml_serde::Value::Null);
 
-      mapping.insert(serde_yaml::Value::String(key), value);
+      mapping.insert(yaml_serde::Value::String(key), value);
     }
 
-    return serde_yaml::Value::Mapping(mapping);
+    return yaml_serde::Value::Mapping(mapping);
   }
 
   if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
-    let values: Vec<serde_yaml::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
+    let values: Vec<yaml_serde::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
 
-    return serde_yaml::Value::Sequence(values);
+    return yaml_serde::Value::Sequence(values);
   }
 
   if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
@@ -521,35 +521,35 @@ pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::Value {
 
     let text = dedent_block_scalar(&text);
 
-    return serde_yaml::Value::String(text);
+    return yaml_serde::Value::String(text);
   }
 
   if let Some(scalar) = extract_scalar(node) {
     use crate::syntax::{detect_yaml_type, is_yaml_truthy, YerbaValueType};
 
     return match detect_yaml_type(&scalar) {
-      YerbaValueType::Null => serde_yaml::Value::Null,
-      YerbaValueType::Boolean => serde_yaml::Value::Bool(is_yaml_truthy(&scalar.text)),
+      YerbaValueType::Null => yaml_serde::Value::Null,
+      YerbaValueType::Boolean => yaml_serde::Value::Bool(is_yaml_truthy(&scalar.text)),
 
       YerbaValueType::Integer => scalar
         .text
         .parse::<i64>()
-        .map(|n| serde_yaml::Value::Number(serde_yaml::Number::from(n)))
-        .unwrap_or(serde_yaml::Value::String(scalar.text)),
+        .map(|n| yaml_serde::Value::Number(yaml_serde::Number::from(n)))
+        .unwrap_or(yaml_serde::Value::String(scalar.text)),
 
       YerbaValueType::Float => scalar
         .text
         .parse::<f64>()
-        .map(|n| serde_yaml::Value::Number(serde_yaml::Number::from(n)))
-        .unwrap_or(serde_yaml::Value::String(scalar.text)),
+        .map(|n| yaml_serde::Value::Number(yaml_serde::Number::from(n)))
+        .unwrap_or(yaml_serde::Value::String(scalar.text)),
 
-      YerbaValueType::String => serde_yaml::Value::String(scalar.text),
+      YerbaValueType::String => yaml_serde::Value::String(scalar.text),
     };
   }
 
   let text = node.text().to_string();
 
-  serde_yaml::from_str(&text).unwrap_or(serde_yaml::Value::String(text))
+  yaml_serde::from_str(&text).unwrap_or(yaml_serde::Value::String(text))
 }
 
 pub(crate) fn parse_condition(condition: &str) -> Option<(String, &str, String)> {

data/rust/src/document/sort.rs

@@ -577,10 +577,10 @@ impl Document {
     };
 
     let labels: Vec<String> = match self.get_value(&items_selector) {
-      Some(serde_yaml::Value::Sequence(sequence)) => sequence
+      Some(yaml_serde::Value::Sequence(sequence)) => sequence
         .iter()
         .map(|value| match value {
-          serde_yaml::Value::String(string) => string.clone(),
+          yaml_serde::Value::String(string) => string.clone(),
           _ => String::new(),
         })
         .collect(),

data/rust/src/json.rs

@@ -1,11 +1,11 @@
 use crate::selector::{Selector, SelectorSegment};
 
-pub fn yaml_to_json(value: &serde_yaml::Value) -> serde_json::Value {
+pub fn yaml_to_json(value: &yaml_serde::Value) -> serde_json::Value {
   match value {
-    serde_yaml::Value::Null => serde_json::Value::Null,
-    serde_yaml::Value::Bool(boolean) => serde_json::Value::Bool(*boolean),
+    yaml_serde::Value::Null => serde_json::Value::Null,
+    yaml_serde::Value::Bool(boolean) => serde_json::Value::Bool(*boolean),
 
-    serde_yaml::Value::Number(number) => {
+    yaml_serde::Value::Number(number) => {
       if let Some(integer) = number.as_i64() {
         serde_json::Value::Number(integer.into())
       } else if let Some(float) = number.as_f64() {
@@ -15,16 +15,16 @@ pub fn yaml_to_json(value: &serde_yaml::Value) -> serde_json::Value {
       }
     }
 
-    serde_yaml::Value::String(string) => serde_json::Value::String(string.clone()),
+    yaml_serde::Value::String(string) => serde_json::Value::String(string.clone()),
 
-    serde_yaml::Value::Sequence(sequence) => serde_json::Value::Array(sequence.iter().map(yaml_to_json).collect()),
+    yaml_serde::Value::Sequence(sequence) => serde_json::Value::Array(sequence.iter().map(yaml_to_json).collect()),
 
-    serde_yaml::Value::Mapping(mapping) => {
+    yaml_serde::Value::Mapping(mapping) => {
       let mut map = serde_json::Map::new();
 
       for (key, yaml_value) in mapping {
         let json_key = match key {
-          serde_yaml::Value::String(string) => string.clone(),
+          yaml_serde::Value::String(string) => string.clone(),
           _ => format!("{:?}", key),
         };
 
@@ -34,19 +34,19 @@ pub fn yaml_to_json(value: &serde_yaml::Value) -> serde_json::Value {
       serde_json::Value::Object(map)
     }
 
-    serde_yaml::Value::Tagged(tagged) => yaml_to_json(&tagged.value),
+    yaml_serde::Value::Tagged(tagged) => yaml_to_json(&tagged.value),
   }
 }
 
-pub fn resolve_select_field(value: &serde_yaml::Value, field: &str) -> serde_json::Value {
+pub fn resolve_select_field(value: &yaml_serde::Value, field: &str) -> serde_json::Value {
   let parsed = Selector::parse(field);
   let segments = parsed.segments();
 
   if segments.len() == 1 {
     if let SelectorSegment::Key(key) = &segments[0] {
-      if let serde_yaml::Value::Mapping(map) = value {
+      if let yaml_serde::Value::Mapping(map) = value {
         for (map_key, yaml_value) in map {
-          if let serde_yaml::Value::String(key_string) = map_key {
+          if let yaml_serde::Value::String(key_string) = map_key {
             if key_string == key {
               return yaml_to_json(yaml_value);
             }
@@ -66,13 +66,13 @@ pub fn resolve_select_field(value: &serde_yaml::Value, field: &str) -> serde_jso
     for current in &current_values {
       match segment {
         SelectorSegment::AllItems => {
-          if let serde_yaml::Value::Sequence(sequence) = current {
+          if let yaml_serde::Value::Sequence(sequence) = current {
             next_values.extend(sequence.iter().cloned());
           }
         }
 
         SelectorSegment::Index(index) => {
-          if let serde_yaml::Value::Sequence(sequence) = current {
+          if let yaml_serde::Value::Sequence(sequence) = current {
             if let Some(item) = sequence.get(*index) {
               next_values.push(item.clone());
             }
@@ -80,9 +80,9 @@ pub fn resolve_select_field(value: &serde_yaml::Value, field: &str) -> serde_jso
         }
 
         SelectorSegment::Key(key) => {
-          if let serde_yaml::Value::Mapping(map) = current {
+          if let yaml_serde::Value::Mapping(map) = current {
             for (map_key, yaml_value) in map {
-              if let serde_yaml::Value::String(key_string) = map_key {
+              if let yaml_serde::Value::String(key_string) = map_key {
                 if key_string == key {
                   next_values.push(yaml_value.clone());
                 }

data/rust/src/lib.rs

@@ -88,10 +88,10 @@ pub fn glob_find(pattern: &str, selector: &str, condition: Option<&str>, select:
               }
             }
             None => {
-              if let serde_yaml::Value::Mapping(map) = value {
+              if let yaml_serde::Value::Mapping(map) = value {
                 for (key, yaml_value) in map {
                   let json_key = match key {
-                    serde_yaml::Value::String(string) => string.clone(),
+                    yaml_serde::Value::String(string) => string.clone(),
                     _ => format!("{:?}", key),
                   };
 

data/rust/src/selector.rs

@@ -171,6 +171,22 @@ impl Selector {
 
     result
   }
+
+  pub fn parent_path(&self) -> String {
+    let segments = self.segments();
+
+    if segments.len() <= 1 {
+      return String::new();
+    }
+
+    let parent_segments = &segments[..segments.len() - 1];
+    let parent = match self {
+      Selector::Relative(_) => Selector::Relative(parent_segments.to_vec()),
+      Selector::Absolute(_) => Selector::Absolute(parent_segments.to_vec()),
+    };
+
+    parent.to_selector_string()
+  }
 }
 
 fn parse_segments(input: &str) -> Vec<SelectorSegment> {

data/rust/src/yerbafile.rs

@@ -108,65 +108,65 @@ impl<'de> Deserialize<'de> for PipelineStep {
   where
     D: serde::Deserializer<'de>,
   {
-    let mapping = serde_yaml::Mapping::deserialize(deserializer)?;
+    let mapping = yaml_serde::Mapping::deserialize(deserializer)?;
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("sort_keys".to_string())) {
-      let config: SortKeysConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("sort_keys".to_string())) {
+      let config: SortKeysConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::SortKeys(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("quote_style".to_string())) {
-      let config: QuoteStyleConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("quote_style".to_string())) {
+      let config: QuoteStyleConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::QuoteStyle(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("set".to_string())) {
-      let config: SetConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("set".to_string())) {
+      let config: SetConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Set(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("insert".to_string())) {
-      let config: InsertConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("insert".to_string())) {
+      let config: InsertConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Insert(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("delete".to_string())) {
-      let config: DeleteConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("delete".to_string())) {
+      let config: DeleteConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Delete(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("rename".to_string())) {
-      let config: RenameConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("rename".to_string())) {
+      let config: RenameConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Rename(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("remove".to_string())) {
-      let config: RemoveConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("remove".to_string())) {
+      let config: RemoveConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Remove(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("blank_lines".to_string())) {
-      let config: BlankLinesConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("blank_lines".to_string())) {
+      let config: BlankLinesConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::BlankLines(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("directives".to_string())) {
-      let config: DirectivesConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("directives".to_string())) {
+      let config: DirectivesConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Directives(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("sort".to_string())) {
-      let config: SortConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("sort".to_string())) {
+      let config: SortConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Sort(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("unique".to_string())) {
-      let config: UniqueConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("unique".to_string())) {
+      let config: UniqueConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Unique(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("schema".to_string())) {
-      let config: SchemaConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("schema".to_string())) {
+      let config: SchemaConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Schema(config));
     }
 
@@ -229,7 +229,7 @@ pub struct RuleResult {
 impl Yerbafile {
   pub fn load(path: impl AsRef<Path>) -> Result<Self, YerbaError> {
     let content = fs::read_to_string(path.as_ref())?;
-    let mut yerbafile: Yerbafile = serde_yaml::from_str(&content).map_err(|error| YerbaError::ParseError(format!("{}", error)))?;
+    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());
     Ok(yerbafile)
   }
@@ -311,50 +311,6 @@ impl Yerbafile {
 
       let file_strings: Vec<String> = files.iter().map(|path| path.to_string_lossy().to_string()).collect();
 
-      let mut has_validation_error = false;
-
-      for step in &rule.pipeline {
-        if let PipelineStep::SortKeys(config) = step {
-          let full_path = resolve_step_path(rule.path.as_deref(), config.path.as_deref());
-          let key_order: Vec<&str> = config.order.iter().map(|key| key.as_str()).collect();
-
-          let validation_results: Vec<RuleResult> = file_strings
-            .par_iter()
-            .filter_map(|file| {
-              let document = match Document::parse_file(file) {
-                Ok(document) => document,
-                Err(error) => {
-                  return Some(RuleResult {
-                    file: file.clone(),
-                    changed: false,
-                    error: Some(error),
-                  });
-                }
-              };
-
-              if let Err(error) = document.validate_sort_keys(&full_path, &key_order) {
-                Some(RuleResult {
-                  file: file.clone(),
-                  changed: false,
-                  error: Some(error),
-                })
-              } else {
-                None
-              }
-            })
-            .collect();
-
-          if !validation_results.is_empty() {
-            has_validation_error = true;
-            results.extend(validation_results);
-          }
-        }
-      }
-
-      if has_validation_error {
-        continue;
-      }
-
       let file_results: Vec<RuleResult> = file_strings.par_iter().map(|file| self.apply_pipeline_to_file(rule, file, write)).collect();
 
       results.extend(file_results);
@@ -474,6 +430,7 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
       let full_path = resolve_step_path(base_path, config.path.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)
     }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: x86_64-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-05-12 00:00:00.000000000 Z
+date: 2026-05-19 00:00:00.000000000 Z
 dependencies: []
 description: A CLI tool for editing YAML while preserving structure, comments, and
   format.