yerba 0.7.6-x86_64-linux-gnu → 0.8.0-x86_64-linux-gnu

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

@@ -279,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),
@@ -675,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(());
         }
       }
@@ -689,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(());
         }
       }
@@ -707,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;
             }
           }
@@ -720,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(());
           }
         }
@@ -735,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(());
         }
       }
@@ -749,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(());
         }
       }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.8.0
 platform: x86_64-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-07-08 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.