yerba 0.2.1-x86_64-linux-gnu → 0.3.0-x86_64-linux-gnu

data/rust/src/commands/mod.rs

@@ -11,6 +11,7 @@ pub mod move_key;
 pub mod quote_style;
 pub mod remove;
 pub mod rename;
+pub mod selectors;
 pub mod set;
 pub mod sort;
 pub mod sort_keys;
@@ -153,6 +154,7 @@ pub enum Command {
   Sort(sort::Args),
   QuoteStyle(quote_style::Args),
   BlankLines(blank_lines::Args),
+  Selectors(selectors::Args),
   #[command(about = "Create a new Yerbafile in the current directory")]
   Init,
   #[command(about = "Apply all rules from the Yerbafile and write changes")]
@@ -180,6 +182,7 @@ impl Command {
       Command::Sort(args) => args.run(),
       Command::QuoteStyle(args) => args.run(),
       Command::BlankLines(args) => args.run(),
+      Command::Selectors(args) => args.run(),
       Command::Init => init::run(),
       Command::Apply => apply::run(),
       Command::Check => check::run(),
@@ -224,7 +227,7 @@ pub(crate) fn run_yerbafile(write: bool) {
   }
 
   if !has_changes && !has_errors {
-    eprintln!("  {GREEN}All files match the rules.{RESET}");
+    eprintln!("\n{BOLD}{GREEN}All files match the rules.{RESET}");
   }
 
   if !write && has_changes {
@@ -327,13 +330,77 @@ pub(crate) fn parse_file(file: &str) -> yerba::Document {
   })
 }
 
-pub(crate) fn run_op(operation: impl FnOnce() -> Result<(), yerba::YerbaError>) {
+pub(crate) fn run_op(file: &str, document: &yerba::Document, result: Result<(), yerba::YerbaError>) {
+  run_op_with_hint(file, document, result, None);
+}
+
+pub(crate) fn run_op_with_hint(
+  file: &str,
+  document: &yerba::Document,
+  result: Result<(), yerba::YerbaError>,
+  hint: Option<&str>,
+) {
   use color::*;
 
-  operation().unwrap_or_else(|error| {
-    eprintln!("{RED}Error:{RESET} {}", error);
+  if let Err(error) = result {
+    if let yerba::YerbaError::SelectorNotFound(selector) = &error {
+      eprintln!("{RED}Error:{RESET} selector \"{selector}\" not found in {file}");
+
+      show_similar_selectors(file, document, selector);
+    } else {
+      eprintln!("{RED}Error:{RESET} {}", error);
+    }
+
+    if let Some(hint) = hint {
+      if matches!(error, yerba::YerbaError::SelectorNotFound(_)) {
+        eprintln!();
+        eprintln!("  {DIM}Hint: {hint}{RESET}");
+      }
+    }
+
     process::exit(1);
-  });
+  }
+}
+
+pub(crate) fn show_similar_selectors(file: &str, document: &yerba::Document, invalid_path: &str) {
+  use color::*;
+  use yerba::didyoumean::didyoumean_ranked;
+
+  let selectors = document.selectors();
+
+  if selectors.is_empty() {
+    return;
+  }
+
+  let query = invalid_path.split_whitespace().next().unwrap_or(invalid_path);
+  let threshold = query.len() / 2 + 3;
+  let close = didyoumean_ranked(query, &selectors, threshold);
+
+  eprintln!();
+
+  if close.is_empty() {
+    eprintln!("  {BOLD}Available selectors in {file}:{RESET}");
+
+    for selector in selectors.iter().take(10) {
+      eprintln!("    {DIM}{selector}{RESET}");
+    }
+
+    if selectors.len() > 10 {
+      eprintln!("    {DIM}... and {} more{RESET}", selectors.len() - 10);
+    }
+  } else if close.len() == 1 {
+    eprintln!("  {BOLD}Did you mean this selector?{RESET} {}", close[0]);
+  } else {
+    eprintln!("  {BOLD}Did you mean one of these selectors?{RESET}");
+
+    for selector in close.iter().take(5) {
+      eprintln!("    {selector}");
+    }
+  }
+
+  eprintln!();
+  eprintln!("  {BOLD}To see all valid selectors, run:{RESET}");
+  eprintln!("    yerba selectors \"{file}\"{RESET}");
 }
 
 pub(crate) fn output(file: &str, document: &yerba::Document, dry_run: bool) {

data/rust/src/commands/move_item.rs

@@ -48,7 +48,8 @@ impl Args {
       |document, path, reference| document.resolve_sequence_index(path, reference),
     );
 
-    run_op(|| document.move_item(&self.selector, from_index, to_index));
+    let result = document.move_item(&self.selector, from_index, to_index);
+    run_op(&self.file, &document, result);
     output(&self.file, &document, self.dry_run);
   }
 }

data/rust/src/commands/move_key.rs

@@ -81,7 +81,8 @@ impl Args {
       |document, parent_path, reference| document.resolve_key_index(parent_path, reference),
     );
 
-    run_op(|| document.move_key(parent_path, from_index, to_index));
+    let result = document.move_key(parent_path, from_index, to_index);
+    run_op(&self.file, &document, result);
     output(&self.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,174 @@
+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);
+    }
   }
 }