yerba 0.7.5-x86_64-linux-gnu → 0.8.0-x86_64-linux-gnu

data/rust/src/document/style.rs

@@ -656,6 +656,18 @@ impl Document {
     self.reparse(&new_source)
   }
 
+  pub fn enforce_final_newline(&mut self, count: usize) -> Result<(), YerbaError> {
+    let source = self.to_string();
+    let trimmed = source.trim_end_matches('\n');
+    let expected = format!("{}{}", trimmed, "\n".repeat(count));
+
+    if source != expected {
+      self.reparse(&expected)
+    } else {
+      Ok(())
+    }
+  }
+
   pub fn enforce_key_style(&mut self, style: &crate::KeyStyle, dot_path: Option<&str>) -> Result<(), YerbaError> {
     let scope_ranges: Vec<TextRange> = match dot_path {
       Some(path) if !path.is_empty() => self.navigate_all_compact(path).iter().map(|node| node.text_range()).collect(),

data/rust/src/error.rs

@@ -4,7 +4,9 @@ pub enum YerbaError {
   IoError(std::io::Error),
   SelectorNotFound(String),
   AmbiguousSelector(String, usize),
+  InvalidCondition(String, String),
   NotASequence(String),
+  FlowCollectionNotWritable(String),
   IndexOutOfBounds(usize, usize),
   UnknownKeys(Vec<String>),
   DuplicateValues(Vec<crate::DuplicateInfo>),
@@ -25,6 +27,14 @@ impl std::fmt::Display for YerbaError {
       YerbaError::SelectorNotFound(selector) => write!(f, "selector not found: {}", selector),
       YerbaError::NotASequence(path) => write!(f, "not a sequence: {}", path),
 
+      YerbaError::FlowCollectionNotWritable(path) => {
+        write!(
+          f,
+          "cannot write to \"{}\": flow collections are not writable yet. Convert it to block style first, with `collection_style` or `yerba collection-style`",
+          path
+        )
+      }
+
       YerbaError::AmbiguousSelector(selector, count) => {
         write!(
           f,
@@ -33,6 +43,10 @@ impl std::fmt::Display for YerbaError {
         )
       }
 
+      YerbaError::InvalidCondition(condition, reason) => {
+        write!(f, "invalid condition \"{}\": {}", condition, reason)
+      }
+
       YerbaError::DuplicateKey {
         key,
         first_line,

data/rust/src/ffi.rs

@@ -330,6 +330,24 @@ pub unsafe extern "C" fn yerba_document_resolve_selectors(document: *const Docum
   CString::new(json_string).unwrap_or_default().into_raw()
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn yerba_selector_has_wildcard(path: *const c_char) -> bool {
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+
+  crate::selector::Selector::parse(selector_string).has_wildcard()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_keys(document: *const Document, path: *const c_char) -> *mut c_char {
+  let document = &*document;
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+
+  let keys = document.keys_at(selector_string);
+  let json_string = serde_json::to_string(&keys).unwrap_or_else(|_| "[]".to_string());
+
+  CString::new(json_string).unwrap_or_default().into_raw()
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_get_quote_style(document: *const Document, path: *const c_char) -> *mut c_char {
   let document = &*document;
@@ -409,12 +427,33 @@ pub unsafe extern "C" fn yerba_document_set_sequence_indent(document: *mut Docum
   }
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn yerba_validate_condition(condition: *const c_char, item_context: bool) -> *mut c_char {
+  if condition.is_null() {
+    return ptr::null_mut();
+  }
+
+  let cond = CStr::from_ptr(condition).to_str().unwrap_or("");
+
+  let result = if item_context {
+    crate::validate_item_condition(cond)
+  } else {
+    crate::validate_condition(cond)
+  };
+
+  match result {
+    Ok(()) => ptr::null_mut(),
+    Err(error) => CString::new(error.to_string()).unwrap_or_default().into_raw(),
+  }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_evaluate_condition(document: *const Document, parent_path: *const c_char, condition: *const c_char) -> bool {
   let document = &*document;
   let parent = CStr::from_ptr(parent_path).to_str().unwrap_or("");
   let cond = CStr::from_ptr(condition).to_str().unwrap_or("");
-  document.evaluate_condition(parent, cond)
+
+  document.evaluate_condition(parent, cond).unwrap_or(false)
 }
 
 #[no_mangle]
@@ -440,7 +479,7 @@ pub unsafe extern "C" fn yerba_document_find(document: *const Document, path: *c
 
   let select_string = if select.is_null() { None } else { CStr::from_ptr(select).to_str().ok() };
 
-  let results = document.find_items(selector_string, condition_string, select_string);
+  let results = document.find_items(selector_string, condition_string, select_string).unwrap_or_default();
   let json = serde_json::to_string_pretty(&results).unwrap_or_else(|_| "[]".to_string());
 
   CString::new(json).unwrap_or_default().into_raw()
@@ -830,12 +869,7 @@ pub unsafe extern "C" fn yerba_get_result_free(result: YerbaGetResult) {
   }
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *const c_char) -> YerbaTypedList {
-  let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
-  let nodes = crate::glob_get(pattern, selector_string);
-
+fn located_nodes_to_list(nodes: &[crate::LocatedNode]) -> YerbaTypedList {
   let results: Vec<serde_json::Value> = nodes
     .iter()
     .map(|node| {
@@ -865,6 +899,18 @@ pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *cons
         value["type"] = serde_json::json!(vt as u8);
       }
 
+      if let Some(key_name) = &node.key_name {
+        value["key_name"] = serde_json::json!(key_name);
+        value["key_location"] = serde_json::json!({
+          "start_line": node.key_location.start_line,
+          "start_column": node.key_location.start_column,
+          "end_line": node.key_location.end_line,
+          "end_column": node.key_location.end_column,
+          "start_offset": node.key_location.start_offset,
+          "end_offset": node.key_location.end_offset,
+        });
+      }
+
       value
     })
     .collect();
@@ -878,6 +924,22 @@ pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *cons
   }
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *const c_char) -> YerbaTypedList {
+  let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+
+  located_nodes_to_list(&crate::glob_get(pattern, selector_string))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_get_all(document: *const Document, path: *const c_char) -> YerbaTypedList {
+  let document = &*document;
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+
+  located_nodes_to_list(&document.get_all_located(selector_string))
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_glob_find(glob_pattern: *const c_char, path: *const c_char, condition: *const c_char, select: *const c_char) -> YerbaTypedList {
   let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");
@@ -885,7 +947,7 @@ pub unsafe extern "C" fn yerba_glob_find(glob_pattern: *const c_char, path: *con
   let condition_string = if condition.is_null() { None } else { CStr::from_ptr(condition).to_str().ok() };
   let select_string = if select.is_null() { None } else { CStr::from_ptr(select).to_str().ok() };
 
-  let all_results = crate::glob_find(pattern, selector_string, condition_string, select_string);
+  let all_results = crate::glob_find(pattern, selector_string, condition_string, select_string).unwrap_or_default();
   let length = all_results.len();
   let json = serde_json::to_string_pretty(&all_results).unwrap_or_else(|_| "[]".to_string());
 

data/rust/src/json.rs

@@ -71,6 +71,12 @@ pub fn resolve_select_field(value: &yaml_serde::Value, field: &str) -> serde_jso
           }
         }
 
+        SelectorSegment::AllKeys => {
+          if let yaml_serde::Value::Mapping(mapping) = current {
+            next_values.extend(mapping.iter().map(|(_, entry)| entry.clone()));
+          }
+        }
+
         SelectorSegment::Index(index) => {
           if let yaml_serde::Value::Sequence(sequence) = current {
             if let Some(item) = sequence.get(*index) {
@@ -96,7 +102,10 @@ pub fn resolve_select_field(value: &yaml_serde::Value, field: &str) -> serde_jso
     current_values = next_values;
   }
 
-  let used_all_items = parsed.segments().iter().any(|s| matches!(s, SelectorSegment::AllItems));
+  let used_all_items = parsed
+    .segments()
+    .iter()
+    .any(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::AllKeys));
 
   if current_values.is_empty() {
     if used_all_items {

data/rust/src/lib.rs

@@ -11,7 +11,9 @@ mod yaml_writer;
 pub mod yerbafile;
 
 pub use document::style::StyleEnforcement;
-pub use document::{collect_selectors, Document, DuplicateInfo, InsertPosition, LocatedNode, Location, NodeInfo, NodeType, SortField};
+pub use document::{
+  collect_selectors, validate_condition, validate_item_condition, Document, DuplicateInfo, InsertPosition, LocatedNode, Location, NodeInfo, NodeType, SortField,
+};
 pub use error::YerbaError;
 pub use quote_style::{KeyStyle, QuoteStyle};
 pub use selector::Selector;
@@ -53,24 +55,28 @@ pub fn glob_get(pattern: &str, selector: &str) -> Vec<document::LocatedNode> {
     .collect()
 }
 
-pub fn glob_find(pattern: &str, selector: &str, condition: Option<&str>, select: Option<&str>) -> Vec<serde_json::Value> {
+pub fn glob_find(pattern: &str, selector: &str, condition: Option<&str>, select: Option<&str>) -> Result<Vec<serde_json::Value>, YerbaError> {
   use rayon::prelude::*;
 
+  if let Some(cond) = condition {
+    crate::document::validate_condition(cond)?;
+  }
+
   let files = match glob::glob(pattern) {
     Ok(paths) => paths.filter_map(|p| p.ok()).collect::<Vec<_>>(),
-    Err(_) => return vec![],
+    Err(_) => return Ok(vec![]),
   };
 
   let select_fields: Option<Vec<&str>> = select.map(|s| s.split(',').collect());
 
-  files
+  let results: Vec<serde_json::Value> = files
     .par_iter()
     .flat_map(|file| {
       let mut file_results = Vec::new();
 
       if let Ok(document) = Document::parse_file(file) {
         let values = match condition {
-          Some(cond) => document.filter(selector, cond),
+          Some(cond) => document.filter(selector, cond).unwrap_or_default(),
           None => document.get_values(selector),
         };
 
@@ -108,5 +114,7 @@ pub fn glob_find(pattern: &str, selector: &str, condition: Option<&str>, select:
 
       file_results
     })
-    .collect()
+    .collect();
+
+  Ok(results)
 }

data/rust/src/main.rs

@@ -20,6 +20,7 @@ static HELP: LazyLock<String> = LazyLock::new(|| {
       key.nested           Nested key path       "database.settings.pool"
       []                   All items in array    "[].title"
       [N]                  Item at index         "[0].title"
+      *                    All values in a map   "database.*"
       [].key[].nested      Nested array access   "[].speakers[].name"
 
     Conditions:

data/rust/src/selector.rs

@@ -21,6 +21,7 @@ pub enum Selector {
 pub enum SelectorSegment {
   Key(String),
   AllItems,
+  AllKeys,
   Index(usize),
 }
 
@@ -69,7 +70,10 @@ impl Selector {
   }
 
   pub fn has_wildcard(&self) -> bool {
-    self.segments().iter().any(|s| matches!(s, SelectorSegment::AllItems))
+    self
+      .segments()
+      .iter()
+      .any(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::AllKeys))
   }
 
   /// Split into the container selector (up to and including the last []) and the remaining field selector.
@@ -163,6 +167,14 @@ impl Selector {
           result.push_str("[]");
         }
 
+        SelectorSegment::AllKeys => {
+          if index > 0 && !result.ends_with('.') {
+            result.push('.');
+          }
+
+          result.push('*');
+        }
+
         SelectorSegment::Index(i) => {
           result.push_str(&format!("[{}]", i));
         }
@@ -227,7 +239,9 @@ fn parse_segments(input: &str) -> Vec<SelectorSegment> {
         Some(index) => {
           let key = &rest[..index];
 
-          if !key.is_empty() {
+          if key == "*" {
+            segments.push(SelectorSegment::AllKeys);
+          } else if !key.is_empty() {
             segments.push(SelectorSegment::Key(key.to_string()));
           }
 
@@ -238,7 +252,9 @@ fn parse_segments(input: &str) -> Vec<SelectorSegment> {
           }
         }
         None => {
-          if !rest.is_empty() {
+          if rest == "*" {
+            segments.push(SelectorSegment::AllKeys);
+          } else if !rest.is_empty() {
             segments.push(SelectorSegment::Key(rest.to_string()));
           }
 

data/rust/src/syntax.rs

@@ -1,7 +1,7 @@
 use rowan::ast::AstNode;
 use rowan::{TextRange, TextSize};
 
-use yaml_parser::ast::{BlockMap, BlockMapEntry, BlockSeq};
+use yaml_parser::ast::{BlockMap, BlockMapEntry, BlockSeq, FlowMap, FlowMapEntry, FlowSeq};
 use yaml_parser::{SyntaxKind, SyntaxNode, SyntaxToken};
 
 #[derive(Debug, Clone, PartialEq)]
@@ -82,6 +82,46 @@ pub fn find_block_sequence(node: &SyntaxNode) -> Option<BlockSeq> {
   node.descendants().find_map(BlockSeq::cast)
 }
 
+fn first_collection_node(node: &SyntaxNode) -> Option<SyntaxNode> {
+  node.descendants().find(|descendant| {
+    matches!(
+      descendant.kind(),
+      SyntaxKind::BLOCK_MAP | SyntaxKind::BLOCK_SEQ | SyntaxKind::FLOW_MAP | SyntaxKind::FLOW_SEQ
+    )
+  })
+}
+
+pub fn find_flow_sequence(node: &SyntaxNode) -> Option<FlowSeq> {
+  first_collection_node(node).and_then(FlowSeq::cast)
+}
+
+pub fn find_flow_map(node: &SyntaxNode) -> Option<FlowMap> {
+  first_collection_node(node).and_then(FlowMap::cast)
+}
+
+pub fn flow_sequence_entries(sequence: &FlowSeq) -> Vec<SyntaxNode> {
+  sequence
+    .entries()
+    .map(|entries| entries.entries().map(|entry| entry.syntax().clone()).collect())
+    .unwrap_or_default()
+}
+
+pub fn flow_map_entries(map: &FlowMap) -> Vec<FlowMapEntry> {
+  map.entries().map(|entries| entries.entries().collect()).unwrap_or_default()
+}
+
+pub fn find_flow_entry_by_key(map: &FlowMap, key: &str) -> Option<FlowMapEntry> {
+  flow_map_entries(map)
+    .into_iter()
+    .find(|entry| entry.key().and_then(|found| extract_scalar_text(found.syntax())).as_deref() == Some(key))
+}
+
+pub fn in_flow_collection(node: &SyntaxNode) -> bool {
+  node
+    .ancestors()
+    .any(|ancestor| matches!(ancestor.kind(), SyntaxKind::FLOW_MAP | SyntaxKind::FLOW_SEQ))
+}
+
 pub enum FirstCollection {
   Map(BlockMap),
   Sequence(BlockSeq),
@@ -288,7 +328,7 @@ pub fn is_yaml_non_string(value: &str) -> bool {
 }
 
 pub fn is_yaml_truthy(value: &str) -> bool {
-  matches!(value, "true" | "True" | "TRUE" | "yes" | "Yes" | "YES" | "on" | "On" | "ON" | "y" | "Y")
+  matches!(value, "true" | "True" | "TRUE" | "yes" | "Yes" | "YES" | "on" | "On" | "ON")
 }
 
 pub fn detect_yaml_type_from_plain(value: &str) -> YerbaValueType {
@@ -297,31 +337,12 @@ pub fn detect_yaml_type_from_plain(value: &str) -> YerbaValueType {
     return YerbaValueType::Null;
   }
 
-  // Boolean (YAML 1.2 + 1.1)
+  // Boolean, resolved the way libyaml/Psych resolve it: the YAML 1.1 bool set
+  // without the single-letter y/Y/n/N forms (which libyaml treats as strings),
+  // and broader than YAML 1.2 core schema (which only accepts true/false).
   if matches!(
     value,
-    "true"
-      | "True"
-      | "TRUE"
-      | "false"
-      | "False"
-      | "FALSE"
-      | "yes"
-      | "Yes"
-      | "YES"
-      | "no"
-      | "No"
-      | "NO"
-      | "on"
-      | "On"
-      | "ON"
-      | "off"
-      | "Off"
-      | "OFF"
-      | "y"
-      | "Y"
-      | "n"
-      | "N"
+    "true" | "True" | "TRUE" | "false" | "False" | "FALSE" | "yes" | "Yes" | "YES" | "no" | "No" | "NO" | "on" | "On" | "ON" | "off" | "Off" | "OFF"
   ) {
     return YerbaValueType::Boolean;
   }

data/rust/src/yerbafile.rs

@@ -41,6 +41,7 @@ pub enum PipelineStep {
   Directives(DirectivesConfig),
   Unique(UniqueConfig),
   Schema(SchemaConfig),
+  FinalNewline(FinalNewlineConfig),
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -95,6 +96,16 @@ pub struct SchemaConfig {
   pub items: bool,
 }
 
+#[derive(Debug, Clone, Deserialize)]
+pub struct FinalNewlineConfig {
+  #[serde(default = "default_one")]
+  pub count: usize,
+}
+
+fn default_one() -> usize {
+  1
+}
+
 #[derive(Debug, Clone, Deserialize)]
 pub struct RenameConfig {
   pub from: String,
@@ -188,8 +199,13 @@ impl<'de> Deserialize<'de> for PipelineStep {
       return Ok(PipelineStep::Schema(config));
     }
 
+    if let Some(value) = mapping.get(yaml_serde::Value::String("final_newline".to_string())) {
+      let config: FinalNewlineConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+      return Ok(PipelineStep::FinalNewline(config));
+    }
+
     Err(serde::de::Error::custom(
-      "unknown pipeline step: expected sort_keys, quote_style, collection_style, sequence_indent, set, insert, delete, rename, remove, blank_lines, sort, directives, unique, or schema",
+      "unknown pipeline step: expected sort_keys, quote_style, collection_style, sequence_indent, set, insert, delete, rename, remove, blank_lines, sort, directives, unique, schema, or final_newline",
     ))
   }
 }
@@ -263,9 +279,33 @@ 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.validate_conditions()?;
     Ok(yerbafile)
   }
 
+  fn validate_conditions(&self) -> Result<(), YerbaError> {
+    let pipelines = std::iter::once(&self.pipeline).chain(self.rules.iter().map(|rule| &rule.pipeline));
+
+    for pipeline in pipelines {
+      for step in pipeline {
+        let condition = match step {
+          PipelineStep::Set(config) => config.condition.as_deref(),
+          PipelineStep::Insert(config) => config.condition.as_deref(),
+          PipelineStep::Delete(config) => config.condition.as_deref(),
+          PipelineStep::Rename(config) => config.condition.as_deref(),
+          PipelineStep::Remove(config) => config.condition.as_deref(),
+          _ => None,
+        };
+
+        if let Some(condition) = condition {
+          crate::validate_condition(condition)?;
+        }
+      }
+    }
+
+    Ok(())
+  }
+
   pub fn resolve_path(&self, relative: &str) -> PathBuf {
     match &self.directory {
       Some(directory) => directory.join(relative),
@@ -359,6 +399,22 @@ impl Yerbafile {
       results.extend(file_results);
     }
 
+    if !self.pipeline.is_empty() {
+      if let Some(ref global_glob) = self.files {
+        if let Ok(paths) = glob::glob(global_glob) {
+          let unprocessed: Vec<String> = paths
+            .filter_map(|entry| entry.ok())
+            .map(|path| path.to_string_lossy().to_string())
+            .filter(|file| !globally_processed.contains(file.as_str()))
+            .collect();
+
+          let global_results: Vec<RuleResult> = unprocessed.par_iter().map(|file| self.apply_global_pipeline_to_file(file, write)).collect();
+
+          results.extend(global_results);
+        }
+      }
+    }
+
     results
   }
 
@@ -436,9 +492,55 @@ impl Yerbafile {
       ran_global = true;
     }
 
+    if !ran_global && self.should_run_global_pipeline(file) {
+      results.push(self.apply_global_pipeline_to_file(file, write));
+    }
+
     results
   }
 
+  fn apply_global_pipeline_to_file(&self, file: &str, write: bool) -> RuleResult {
+    let mut document = match Document::parse_file(file) {
+      Ok(document) => document,
+      Err(error) => {
+        return RuleResult {
+          file: file.to_string(),
+          changed: false,
+          error: Some(error),
+        }
+      }
+    };
+
+    let original = document.to_string();
+
+    if let Err(error) = execute_pipeline(&mut document, &self.pipeline, None, file, self) {
+      return RuleResult {
+        file: file.to_string(),
+        changed: false,
+        error: Some(error),
+      };
+    }
+
+    let new_content = document.to_string();
+    let changed = new_content != original;
+
+    if changed && write {
+      if let Err(error) = fs::write(file, &new_content) {
+        return RuleResult {
+          file: file.to_string(),
+          changed,
+          error: Some(YerbaError::IoError(error)),
+        };
+      }
+    }
+
+    RuleResult {
+      file: file.to_string(),
+      changed,
+      error: None,
+    }
+  }
+
   fn relativize_path(&self, file_path: &str) -> Option<String> {
     let path = Path::new(file_path);
 
@@ -597,7 +699,7 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
       if let Some(condition) = &config.condition {
         let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-        if !document.evaluate_condition(parent_path, condition) {
+        if !document.evaluate_condition(parent_path, condition)? {
           return Ok(());
         }
       }
@@ -611,7 +713,7 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
       if let Some(condition) = &config.condition {
         let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-        if !document.evaluate_condition(parent_path, condition) {
+        if !document.evaluate_condition(parent_path, condition)? {
           return Ok(());
         }
       }
@@ -629,7 +731,7 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
           if let Some(condition) = &config.condition {
             let parent_path = selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-            if !document.evaluate_condition(parent_path, condition) {
+            if !document.evaluate_condition(parent_path, condition)? {
               continue;
             }
           }
@@ -642,7 +744,7 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
         if let Some(condition) = &config.condition {
           let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-          if !document.evaluate_condition(parent_path, condition) {
+          if !document.evaluate_condition(parent_path, condition)? {
             return Ok(());
           }
         }
@@ -657,7 +759,7 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
       if let Some(condition) = &config.condition {
         let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-        if !document.evaluate_condition(parent_path, condition) {
+        if !document.evaluate_condition(parent_path, condition)? {
           return Ok(());
         }
       }
@@ -671,7 +773,7 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
       if let Some(condition) = &config.condition {
         let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-        if !document.evaluate_condition(parent_path, condition) {
+        if !document.evaluate_condition(parent_path, condition)? {
           return Ok(());
         }
       }
@@ -744,6 +846,8 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
 
       Ok(())
     }
+
+    PipelineStep::FinalNewline(config) => document.enforce_final_newline(config.count),
   }
 }
 

metadata

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