yerba 0.2.2-aarch64-linux-gnu → 0.4.0-aarch64-linux-gnu

data/rust/src/commands/quote_style.rs

@@ -11,7 +11,7 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
     yerba quote-style config.yml --keys plain
     yerba quote-style config.yml --keys plain --values double
     yerba quote-style config.yml "[].speakers" --values plain
-    yerba quote-style "data/**/*.yml" --keys plain --values double 
+    yerba quote-style "data/**/*.yml" --keys plain --values double
   "#})
 });
 
@@ -25,12 +25,12 @@ pub struct Args {
   file: String,
   /// Selector to scope the operation (optional — omit for whole file)
   selector: Option<String>,
-  /// Quote style for values (plain, single, double, literal, folded)
+  /// Quote style for keys
   #[arg(long)]
-  values: Option<yerba::QuoteStyle>,
-  /// Quote style for keys (plain, single, double)
+  keys: Option<yerba::KeyStyle>,
+  /// Quote style for values
   #[arg(long)]
-  keys: Option<yerba::QuoteStyle>,
+  values: Option<yerba::QuoteStyle>,
   #[arg(long)]
   dry_run: bool,
 }
@@ -53,7 +53,13 @@ impl Args {
       }
 
       if let Some(style) = &self.values {
-        let _ = document.enforce_quotes_at(style, selector);
+        if let Ok(warnings) = document.enforce_quotes_at(style, selector) {
+          for warning in warnings {
+            use super::color::*;
+
+            eprintln!("{YELLOW}Warning:{RESET} {} — {}", resolved_file, warning);
+          }
+        }
       }
 
       output(&resolved_file, &document, self.dry_run);

data/rust/src/commands/remove.rs

@@ -3,7 +3,7 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{output, parse_file, run_op};
+use super::{output, parse_file, resolve_files, run_op};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
@@ -28,8 +28,12 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    let mut document = parse_file(&self.file);
-    run_op(|| document.remove(&self.selector, &self.value));
-    output(&self.file, &document, self.dry_run);
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+      let result = document.remove(&self.selector, &self.value);
+
+      run_op(&resolved_file, &document, result);
+      output(&resolved_file, &document, self.dry_run);
+    }
   }
 }

data/rust/src/commands/rename.rs

@@ -3,7 +3,7 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{output, parse_file, run_op};
+use super::{output, parse_file, resolve_files, run_op};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
@@ -30,8 +30,12 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    let mut document = parse_file(&self.file);
-    run_op(|| document.rename(&self.source, &self.destination));
-    output(&self.file, &document, self.dry_run);
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+      let result = document.rename(&self.source, &self.destination);
+
+      run_op(&resolved_file, &document, result);
+      output(&resolved_file, &document, self.dry_run);
+    }
   }
 }

data/rust/src/commands/selectors.rs

@@ -0,0 +1,158 @@
+use std::collections::BTreeMap;
+use std::sync::LazyLock;
+
+use indoc::indoc;
+
+use super::colorize_examples;
+use super::{color, parse_file, resolve_files};
+
+static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
+  colorize_examples(indoc! {r#"
+    yerba selectors config.yml
+    yerba selectors config.yml "database"
+    yerba selectors videos.yml "[]"
+    yerba selectors videos.yml "[].speakers"
+    yerba selectors "data/**/videos.yml"
+    yerba selectors "data/**/videos.yml" "[].talks"
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Show all valid selectors in a YAML file",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  /// Show selectors starting from this path
+  selector: Option<String>,
+  /// Sort selectors alphabetically (default: document order)
+  #[arg(long)]
+  sorted: bool,
+}
+
+#[derive(Debug, Default)]
+struct SelectorInfo {
+  min_count: Option<usize>,
+  max_count: Option<usize>,
+  order: usize,
+}
+
+impl SelectorInfo {
+  fn record_count(&mut self, count: usize) {
+    self.min_count = Some(self.min_count.map_or(count, |min| min.min(count)));
+    self.max_count = Some(self.max_count.map_or(count, |max| max.max(count)));
+  }
+
+  fn count_label(&self) -> Option<String> {
+    match (self.min_count, self.max_count) {
+      (Some(0), Some(0)) => Some("empty".to_string()),
+
+      (Some(min), Some(max)) if min == max => {
+        if max <= 5 {
+          let indices: Vec<String> = (0..max).map(|i| format!("[{}]", i)).collect();
+
+          Some(indices.join(", "))
+        } else {
+          Some(format!("[0]..[{}]", max - 1))
+        }
+      }
+
+      (Some(min), Some(max)) => {
+        if max <= 5 {
+          let indices: Vec<String> = (0..max).map(|i| format!("[{}]", i)).collect();
+
+          Some(format!("{} ({}-{} items)", indices.join(", "), min, max))
+        } else {
+          Some(format!("[0]..[{}] ({}-{} items)", max - 1, min, max))
+        }
+      }
+      _ => None,
+    }
+  }
+}
+
+impl Args {
+  pub fn run(self) {
+    let mut all_selectors: BTreeMap<String, SelectorInfo> = BTreeMap::new();
+    let mut counter: usize = 1;
+    let selector = self.selector.as_deref().unwrap_or("");
+
+    for resolved_file in resolve_files(&self.file) {
+      let document = parse_file(&resolved_file);
+      let prefix = if selector.is_empty() { String::new() } else { selector.to_string() };
+
+      let values = if selector.is_empty() {
+        document.get_value("").into_iter().collect::<Vec<_>>()
+      } else {
+        document.get_values(selector)
+      };
+
+      for value in values {
+        collect_selectors(&value, &prefix, &mut all_selectors, &mut counter);
+      }
+    }
+
+    let mut entries: Vec<(&String, &SelectorInfo)> = all_selectors.iter().collect();
+
+    if self.sorted {
+      entries.sort_by_key(|(name, _)| name.to_string());
+    } else {
+      entries.sort_by_key(|(_, info)| info.order);
+    }
+
+    let max_selector_len = entries.iter().map(|(selector, _)| selector.len()).max().unwrap_or(0);
+
+    for (selector, info) in &entries {
+      if let Some(label) = info.count_label() {
+        let padding = max_selector_len - selector.len() + 2;
+
+        println!("{}{}{}{}{}", selector, " ".repeat(padding), color::DIM, label, color::RESET);
+      } else {
+        println!("{}", selector);
+      }
+    }
+  }
+}
+
+fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mut BTreeMap<String, SelectorInfo>, counter: &mut usize) {
+  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)
+          };
+
+          let entry = selectors.entry(selector.clone()).or_default();
+          if entry.order == 0 {
+            entry.order = *counter;
+            *counter += 1;
+          }
+
+          collect_selectors(child, &selector, selectors, counter);
+        }
+      }
+    }
+
+    serde_yaml::Value::Sequence(sequence) => {
+      let bracket_prefix = format!("{}[]", prefix);
+
+      let entry = selectors.entry(bracket_prefix.clone()).or_default();
+      entry.record_count(sequence.len());
+      if entry.order == 0 {
+        entry.order = *counter;
+        *counter += 1;
+      }
+
+      for item in sequence {
+        collect_selectors(item, &bracket_prefix, selectors, counter);
+      }
+    }
+
+    _ => {}
+  }
+}

data/rust/src/commands/set.rs

@@ -3,7 +3,7 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{output, parse_file, run_op};
+use super::{output, parse_file, resolve_files, run_op_with_hint};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
@@ -12,6 +12,7 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
     yerba set config.yml "database.host" "0.0.0.0" --condition ".port == 5432"
     yerba set videos.yml "[0].title" "New Title"
     yerba set "data/**/event.yml" "website" "" --if-exists
+    yerba set videos.yml "[].description" "" --all
   "#})
 });
 
@@ -32,28 +33,44 @@ pub struct Args {
   #[arg(long)]
   condition: Option<String>,
   #[arg(long)]
+  all: bool,
+  #[arg(long)]
   dry_run: bool,
 }
 
 impl Args {
   pub fn run(self) {
-    let mut document = parse_file(&self.file);
     let parent_path = self.selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
-    let should_set = if self.if_exists {
-      document.exists(&self.selector)
-    } else if self.if_missing {
-      !document.exists(&self.selector)
-    } else if let Some(condition) = &self.condition {
-      document.evaluate_condition(parent_path, condition)
-    } else {
-      true
-    };
-
-    if should_set {
-      run_op(|| document.set(&self.selector, &self.value));
-    }
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+
+      let should_set = if self.if_exists {
+        document.exists(&self.selector)
+      } else if self.if_missing {
+        !document.exists(&self.selector)
+      } else if let Some(condition) = &self.condition {
+        document.evaluate_condition(parent_path, condition)
+      } else {
+        true
+      };
 
-    output(&self.file, &document, self.dry_run);
+      if should_set {
+        let result = if self.all {
+          document.set_all(&self.selector, &self.value)
+        } else {
+          document.set(&self.selector, &self.value)
+        };
+
+        run_op_with_hint(
+          &resolved_file,
+          &document,
+          result,
+          Some("Use --if-exists to skip files where the selector is missing"),
+        );
+      }
+
+      output(&resolved_file, &document, self.dry_run);
+    }
   }
 }