yerba 0.2.2 → 0.3.0

data/rust/src/document.rs

@@ -53,7 +53,7 @@ impl SortField {
   }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum InsertPosition {
   At(usize),
   Last,
@@ -169,6 +169,18 @@ impl Document {
       .collect()
   }
 
+  pub fn selectors(&self) -> Vec<String> {
+    let Some(value) = self.get_value("") else {
+      return Vec::new();
+    };
+
+    let mut selectors = Vec::new();
+    collect_selectors(&value, "", &mut selectors);
+    selectors.sort();
+    selectors.dedup();
+    selectors
+  }
+
   fn evaluate_condition_on_node(&self, node: &SyntaxNode, condition: &str) -> bool {
     let condition = condition.trim();
 
@@ -354,17 +366,35 @@ impl Document {
     }
 
     let scalar_token =
-      find_scalar_token(&current_node).ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+      find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     let new_text = format_scalar_value(value, scalar_token.kind());
 
     self.replace_token(&scalar_token, &new_text)
   }
 
+  pub fn set_all(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
+    let nodes = self.navigate_all(dot_path);
+
+    if nodes.is_empty() {
+      return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
+    }
+
+    for node in nodes.into_iter().rev() {
+      if let Some(scalar_token) = find_scalar_token(&node) {
+        let new_text = format_scalar_value(value, scalar_token.kind());
+
+        self.replace_token(&scalar_token, &new_text)?;
+      }
+    }
+
+    Ok(())
+  }
+
   pub fn set_scalar_style(&mut self, dot_path: &str, style: &QuoteStyle) -> Result<(), YerbaError> {
     let current_node = self.navigate(dot_path)?;
     let scalar_token =
-      find_scalar_token(&current_node).ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+      find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     let current_kind = scalar_token.kind();
     let target_kind = style.to_syntax_kind();
@@ -406,7 +436,7 @@ impl Document {
     }
 
     let scalar_token =
-      find_scalar_token(&current_node).ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+      find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     self.replace_token(&scalar_token, value)
   }
@@ -440,7 +470,7 @@ impl Document {
     let entries: Vec<_> = sequence.entries().collect();
 
     if entries.is_empty() {
-      return Err(YerbaError::PathNotFound(dot_path.to_string()));
+      return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
     }
 
     let indent = entries
@@ -515,7 +545,7 @@ impl Document {
               .map(|text| text == target_value)
               .unwrap_or(false)
           })
-          .ok_or_else(|| YerbaError::PathNotFound(format!("{} item '{}'", dot_path, target_value)))?;
+          .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", dot_path, target_value)))?;
 
         let target_range = target_entry.syntax().text_range();
         let replacement = format!("{}\n{}", new_item, indent);
@@ -534,7 +564,7 @@ impl Document {
               .map(|text| text == target_value)
               .unwrap_or(false)
           })
-          .ok_or_else(|| YerbaError::PathNotFound(format!("{} item '{}'", dot_path, target_value)))?;
+          .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", dot_path, target_value)))?;
 
         let new_text = format!("\n{}{}", indent, new_item);
 
@@ -545,7 +575,7 @@ impl Document {
         let target_entry = entries
           .iter()
           .find(|entry| self.evaluate_condition_on_node(entry.syntax(), &condition))
-          .ok_or_else(|| YerbaError::PathNotFound(format!("{} condition '{}'", dot_path, condition)))?;
+          .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} condition '{}'", dot_path, condition)))?;
 
         let target_range = target_entry.syntax().text_range();
         let replacement = format!("{}\n{}", new_item, indent);
@@ -558,7 +588,7 @@ impl Document {
         let target_entry = entries
           .iter()
           .find(|entry| self.evaluate_condition_on_node(entry.syntax(), &condition))
-          .ok_or_else(|| YerbaError::PathNotFound(format!("{} condition '{}'", dot_path, condition)))?;
+          .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} condition '{}'", dot_path, condition)))?;
 
         let new_text = format!("\n{}{}", indent, new_item);
 
@@ -586,7 +616,7 @@ impl Document {
     let map = current_node
       .descendants()
       .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     let entries: Vec<_> = map.entries().collect();
 
@@ -638,7 +668,7 @@ impl Document {
 
       InsertPosition::Before(target_key) => {
         let target_entry = find_entry_by_key(&map, &target_key)
-          .ok_or_else(|| YerbaError::PathNotFound(format!("{}.{}", dot_path, target_key)))?;
+          .ok_or_else(|| YerbaError::SelectorNotFound(format!("{}.{}", dot_path, target_key)))?;
 
         let target_range = target_entry.syntax().text_range();
         let replacement = format!("{}\n{}", new_entry_text, indent);
@@ -649,7 +679,7 @@ impl Document {
 
       InsertPosition::After(target_key) => {
         let target_entry = find_entry_by_key(&map, &target_key)
-          .ok_or_else(|| YerbaError::PathNotFound(format!("{}.{}", dot_path, target_key)))?;
+          .ok_or_else(|| YerbaError::SelectorNotFound(format!("{}.{}", dot_path, target_key)))?;
 
         let new_text = format!("\n{}{}", indent, new_entry_text);
 
@@ -711,17 +741,17 @@ impl Document {
       let map = parent_node
         .descendants()
         .find_map(BlockMap::cast)
-        .ok_or_else(|| YerbaError::PathNotFound(source_path.to_string()))?;
+        .ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
 
       let entry =
-        find_entry_by_key(&map, source_key).ok_or_else(|| YerbaError::PathNotFound(source_path.to_string()))?;
+        find_entry_by_key(&map, source_key).ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
 
       let key_node = entry
         .key()
-        .ok_or_else(|| YerbaError::PathNotFound(source_path.to_string()))?;
+        .ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
 
       let key_token =
-        find_scalar_token(key_node.syntax()).ok_or_else(|| YerbaError::PathNotFound(source_path.to_string()))?;
+        find_scalar_token(key_node.syntax()).ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
 
       let new_text = format_scalar_value(destination_key, key_token.kind());
 
@@ -729,7 +759,7 @@ impl Document {
     } else {
       let value = self
         .get(source_path)
-        .ok_or_else(|| YerbaError::PathNotFound(source_path.to_string()))?;
+        .ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
 
       self.delete(source_path)?;
       self.insert_into(destination_path, &value, InsertPosition::Last)
@@ -745,9 +775,9 @@ impl Document {
     let map = parent_node
       .descendants()
       .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
-    let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+    let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     self.remove_node(entry.syntax())
   }
@@ -769,7 +799,7 @@ impl Document {
           .map(|text| text == value)
           .unwrap_or(false)
       })
-      .ok_or_else(|| YerbaError::PathNotFound(format!("{} item '{}'", dot_path, value)))?;
+      .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", dot_path, value)))?;
 
     self.remove_node(target_entry.syntax())
   }
@@ -820,7 +850,7 @@ impl Document {
     let map = current_node
       .descendants()
       .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     let entries: Vec<_> = map.entries().collect();
 
@@ -833,7 +863,7 @@ impl Document {
     let map = current_node
       .descendants()
       .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     if let Ok(index) = reference.parse::<usize>() {
       let length = map.entries().count();
@@ -856,7 +886,7 @@ impl Document {
           .unwrap_or(false)
       })
       .map(|(index, _entry)| index)
-      .ok_or_else(|| YerbaError::PathNotFound(format!("{} key '{}'", dot_path, reference)))
+      .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} key '{}'", dot_path, reference)))
   }
 
   pub fn resolve_sequence_index(&self, dot_path: &str, reference: &str) -> Result<usize, YerbaError> {
@@ -883,7 +913,7 @@ impl Document {
         .enumerate()
         .find(|(_index, entry)| self.evaluate_condition_on_node(entry.syntax(), reference))
         .map(|(index, _entry)| index)
-        .ok_or_else(|| YerbaError::PathNotFound(format!("{} condition '{}'", dot_path, reference)));
+        .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} condition '{}'", dot_path, reference)));
     }
 
     sequence
@@ -897,7 +927,7 @@ impl Document {
           .unwrap_or(false)
       })
       .map(|(index, _entry)| index)
-      .ok_or_else(|| YerbaError::PathNotFound(format!("{} item '{}'", dot_path, reference)))
+      .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", dot_path, reference)))
   }
 
   pub fn validate_sort_keys(&self, dot_path: &str, key_order: &[&str]) -> Result<(), YerbaError> {
@@ -916,7 +946,7 @@ impl Document {
     let map = current_node
       .descendants()
       .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     let unknown_keys: Vec<String> = map
       .entries()
@@ -947,7 +977,7 @@ impl Document {
     let map = current_node
       .descendants()
       .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     let entries: Vec<_> = map.entries().collect();
 
@@ -1000,7 +1030,7 @@ impl Document {
       .unwrap_or_default();
 
     let sorted_groups: Vec<EntryGroup> = keyed.into_iter().map(|(_, group)| group).collect();
-    let map_text = rebuild_from_groups(&sorted_groups, &indent);
+    let map_text = rebuild_from_groups(&sorted_groups, &indent, false);
 
     self.apply_edit(range, &map_text)
   }
@@ -1076,7 +1106,7 @@ impl Document {
         .unwrap_or_default();
 
       let sorted_groups: Vec<EntryGroup> = keyed.into_iter().map(|(_, group)| group).collect();
-      let map_text = rebuild_from_groups(&sorted_groups, &indent);
+      let map_text = rebuild_from_groups(&sorted_groups, &indent, false);
       edits.push((group_range, map_text));
     }
 
@@ -1226,7 +1256,7 @@ impl Document {
       .unwrap_or_default();
 
     let sorted_groups: Vec<EntryGroup> = sortable.into_iter().map(|(_, group)| group).collect();
-    let sequence_text = rebuild_from_groups(&sorted_groups, &indent);
+    let sequence_text = rebuild_from_groups(&sorted_groups, &indent, true);
 
     self.apply_edit(range, &sequence_text)
   }
@@ -1334,7 +1364,7 @@ impl Document {
           .unwrap_or_default();
 
         let sorted_groups: Vec<EntryGroup> = sortable.into_iter().map(|(_, group)| group).collect();
-        let sequence_text = rebuild_from_groups(&sorted_groups, &indent);
+        let sequence_text = rebuild_from_groups(&sorted_groups, &indent, true);
         edits.push((group_range, sequence_text));
       }
     }
@@ -1664,12 +1694,12 @@ impl Document {
     Self::validate_path(dot_path)?;
 
     if dot_path.is_empty() {
-      let root = Root::cast(self.root.clone()).ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+      let root = Root::cast(self.root.clone()).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
       let document = root
         .documents()
         .next()
-        .ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+        .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
       return Ok(document.syntax().clone());
     }
@@ -1677,13 +1707,9 @@ impl Document {
     let nodes = self.navigate_all(dot_path);
 
     match nodes.len() {
-      0 => Err(YerbaError::PathNotFound(dot_path.to_string())),
+      0 => Err(YerbaError::SelectorNotFound(dot_path.to_string())),
       1 => Ok(nodes.into_iter().next().unwrap()),
-      _ => Err(YerbaError::PathNotFound(format!(
-        "{} (matched {} nodes, expected 1)",
-        dot_path,
-        nodes.len()
-      ))),
+      _ => Err(YerbaError::AmbiguousSelector(dot_path.to_string(), nodes.len())),
     }
   }
 
@@ -1844,7 +1870,7 @@ impl Document {
       .map(|entry| preceding_whitespace_indent(entry.syntax()))
       .unwrap_or_default();
 
-    let text = rebuild_from_groups(&reordered, &indent);
+    let text = rebuild_from_groups(&reordered, &indent, true);
 
     self.apply_edit(range, &text)
   }
@@ -1871,6 +1897,36 @@ impl std::fmt::Display for Document {
   }
 }
 
+pub fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mut Vec<String>) {
+  match value {
+    serde_yaml::Value::Mapping(map) => {
+      for (key, child) in map {
+        if let serde_yaml::Value::String(key_string) = key {
+          let selector = if prefix.is_empty() {
+            key_string.clone()
+          } else {
+            format!("{}.{}", prefix, key_string)
+          };
+
+          selectors.push(selector.clone());
+          collect_selectors(child, &selector, selectors);
+        }
+      }
+    }
+
+    serde_yaml::Value::Sequence(sequence) => {
+      let bracket_prefix = format!("{}[]", prefix);
+      selectors.push(bracket_prefix.clone());
+
+      for item in sequence {
+        collect_selectors(item, &bracket_prefix, selectors);
+      }
+    }
+
+    _ => {}
+  }
+}
+
 pub fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::Value {
   if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
     let map_position = node
@@ -2178,8 +2234,7 @@ fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String, Option<ro
       Some(parent)
         if parent.kind() == SyntaxKind::BLOCK
           || parent.kind() == SyntaxKind::DOCUMENT
-          || parent.kind() == SyntaxKind::BLOCK_MAP_VALUE
-          || parent.kind() == SyntaxKind::BLOCK_SEQ_ENTRY =>
+          || parent.kind() == SyntaxKind::BLOCK_MAP_VALUE =>
       {
         node = parent
       }
@@ -2214,12 +2269,16 @@ fn collect_groups_with_range(parent: &SyntaxNode) -> (Vec<EntryGroup>, TextRange
   (groups, range)
 }
 
-fn rebuild_from_groups(groups: &[EntryGroup], indent: &str) -> String {
-  let default_separator = groups
-    .iter()
-    .find(|group| !group.separator.is_empty())
-    .map(|group| group.separator.clone())
-    .unwrap_or_else(|| "\n".to_string());
+fn rebuild_from_groups(groups: &[EntryGroup], indent: &str, preserve_separators: bool) -> String {
+  let default_separator = if preserve_separators {
+    groups
+      .iter()
+      .find(|group| !group.separator.is_empty())
+      .map(|group| group.separator.clone())
+      .unwrap_or_else(|| "\n".to_string())
+  } else {
+    "\n".to_string()
+  };
 
   groups
     .iter()
@@ -2227,10 +2286,18 @@ fn rebuild_from_groups(groups: &[EntryGroup], indent: &str) -> String {
     .map(|(index, group)| {
       if index == 0 {
         group.full_text()
-      } else if group.preceding.is_empty() {
-        format!("{}{}{}", default_separator, indent, group.body)
       } else {
-        format!("{}{}\n{}{}", default_separator, group.preceding, indent, group.body)
+        let separator = if preserve_separators && !group.separator.is_empty() {
+          &group.separator
+        } else {
+          &default_separator
+        };
+
+        if group.preceding.is_empty() {
+          format!("{}{}{}", separator, indent, group.body)
+        } else {
+          format!("{}{}\n{}{}", separator, group.preceding, indent, group.body)
+        }
       }
     })
     .collect()

data/rust/src/error.rs

@@ -2,7 +2,8 @@
 pub enum YerbaError {
   ParseError(String),
   IoError(std::io::Error),
-  PathNotFound(String),
+  SelectorNotFound(String),
+  AmbiguousSelector(String, usize),
   NotASequence(String),
   IndexOutOfBounds(usize, usize),
   UnknownKeys(Vec<String>),
@@ -13,7 +14,16 @@ impl std::fmt::Display for YerbaError {
     match self {
       YerbaError::ParseError(msg) => write!(f, "parse error: {}", msg),
       YerbaError::IoError(err) => write!(f, "io error: {}", err),
-      YerbaError::PathNotFound(path) => write!(f, "path not found: {}", path),
+      YerbaError::SelectorNotFound(selector) => write!(f, "selector not found: {}", selector),
+
+      YerbaError::AmbiguousSelector(selector, count) => {
+        write!(
+          f,
+          "selector \"{}\" matched {} nodes (expected 1). Use --all to update all matches",
+          selector, count
+        )
+      }
+
       YerbaError::NotASequence(path) => write!(f, "not a sequence: {}", path),
 
       YerbaError::IndexOutOfBounds(index, length) => {

data/rust/src/ffi.rs

@@ -501,14 +501,19 @@ pub unsafe extern "C" fn yerba_document_set(
   path: *const c_char,
   value: *const c_char,
   value_type: YerbaValueType,
+  all: bool,
 ) -> YerbaResult {
   let document = &mut *document;
   let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
   let value_string = CStr::from_ptr(value).to_str().unwrap_or("");
 
-  let result = match value_type {
-    YerbaValueType::String => document.set(path_string, value_string),
-    _ => document.set_plain(path_string, value_string),
+  let result = if all {
+    document.set_all(path_string, value_string)
+  } else {
+    match value_type {
+      YerbaValueType::String => document.set(path_string, value_string),
+      _ => document.set_plain(path_string, value_string),
+    }
   };
 
   match result {

data/rust/src/lib.rs

@@ -1,3 +1,4 @@
+pub mod didyoumean;
 mod document;
 mod error;
 pub mod ffi;
@@ -8,7 +9,7 @@ mod syntax;
 mod yaml_writer;
 pub mod yerbafile;
 
-pub use document::{Document, InsertPosition, SortField};
+pub use document::{collect_selectors, Document, InsertPosition, SortField};
 pub use error::YerbaError;
 pub use quote_style::QuoteStyle;
 pub use selector::Selector;

data/rust/src/main.rs

@@ -45,6 +45,8 @@ static HELP: LazyLock<String> = LazyLock::new(|| {
       yerba move videos.yml "" ".id == talk-2" --after ".id == talk-1"
       yerba sort-keys config.yml "database" "id,host,port,name"
       yerba quote-style "data/**/*.yml" --values double
+      yerba sort videos.yml "[]" --by ".id" --order "talk-3,talk-1,talk-2"
+      yerba selectors videos.yml
   "#})
 });
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Marco Roth
@@ -53,10 +53,12 @@ files:
 - rust/src/commands/quote_style.rs
 - rust/src/commands/remove.rs
 - rust/src/commands/rename.rs
+- rust/src/commands/selectors.rs
 - rust/src/commands/set.rs
 - rust/src/commands/sort.rs
 - rust/src/commands/sort_keys.rs
 - rust/src/commands/version.rs
+- rust/src/didyoumean.rs
 - rust/src/document.rs
 - rust/src/error.rs
 - rust/src/ffi.rs