yerba 0.3.0-aarch64-linux-gnu → 0.4.1-aarch64-linux-gnu

data/rust/src/commands/mod.rs

@@ -2,6 +2,7 @@ pub mod apply;
 pub mod blank_lines;
 pub mod check;
 pub mod delete;
+pub mod directives;
 pub mod get;
 pub mod init;
 pub mod insert;
@@ -126,10 +127,7 @@ pub(crate) fn colorize_help(input: &str) -> String {
     }
 
     if columns.len() == 3 {
-      output.push_str(&format!(
-        "  \x1b[36m{:<20}{RESET} {:<21} {DIM}{}{RESET}\n",
-        columns[0], columns[1], columns[2]
-      ));
+      output.push_str(&format!("  \x1b[36m{:<20}{RESET} {:<21} {DIM}{}{RESET}\n", columns[0], columns[1], columns[2]));
     } else if columns.len() == 2 {
       output.push_str(&format!("  \x1b[36m{:<20}{RESET} {}\n", columns[0], columns[1]));
     } else {
@@ -154,13 +152,12 @@ pub enum Command {
   Sort(sort::Args),
   QuoteStyle(quote_style::Args),
   BlankLines(blank_lines::Args),
+  Directives(directives::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")]
-  Apply,
-  #[command(about = "Check if all files match Yerbafile rules (exits 1 if not)")]
-  Check,
+  Apply(apply::Args),
+  Check(check::Args),
   #[command(about = "Print the yerba version")]
   Version,
   #[command(about = "\u{1f9c9}")]
@@ -182,17 +179,18 @@ impl Command {
       Command::Sort(args) => args.run(),
       Command::QuoteStyle(args) => args.run(),
       Command::BlankLines(args) => args.run(),
+      Command::Directives(args) => args.run(),
       Command::Selectors(args) => args.run(),
       Command::Init => init::run(),
-      Command::Apply => apply::run(),
-      Command::Check => check::run(),
+      Command::Apply(args) => args.run(),
+      Command::Check(args) => args.run(),
       Command::Version => version::run(),
       Command::Mate => mate::run(),
     }
   }
 }
 
-pub(crate) fn run_yerbafile(write: bool) {
+pub(crate) fn run_yerbafile(write: bool, files: Vec<String>) {
   use color::*;
 
   let yerbafile_path = yerba::Yerbafile::find().unwrap_or_else(|| {
@@ -207,7 +205,12 @@ pub(crate) fn run_yerbafile(write: bool) {
 
   eprintln!("🧉 {BOLD}Using{RESET} {}", yerbafile_path.display());
 
-  let results = yerbafile.apply(write);
+  let results = if files.is_empty() {
+    yerbafile.apply(write)
+  } else {
+    files.iter().flat_map(|file| yerbafile.apply_file(file, write)).collect()
+  };
+
   let mut has_changes = false;
   let mut has_errors = false;
 
@@ -334,12 +337,7 @@ pub(crate) fn run_op(file: &str, document: &yerba::Document, result: Result<(),
   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>,
-) {
+pub(crate) fn run_op_with_hint(file: &str, document: &yerba::Document, result: Result<(), yerba::YerbaError>, hint: Option<&str>) {
   use color::*;
 
   if let Err(error) = result {

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/selectors.rs

@@ -81,11 +81,7 @@ impl Args {
 
     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 prefix = if selector.is_empty() { String::new() } else { selector.to_string() };
 
       let values = if selector.is_empty() {
         document.get_value("").into_iter().collect::<Vec<_>>()
@@ -112,14 +108,7 @@ impl Args {
       if let Some(label) = info.count_label() {
         let padding = max_selector_len - selector.len() + 2;
 
-        println!(
-          "{}{}{}{}{}",
-          selector,
-          " ".repeat(padding),
-          color::DIM,
-          label,
-          color::RESET
-        );
+        println!("{}{}{}{}{}", selector, " ".repeat(padding), color::DIM, label, color::RESET);
       } else {
         println!("{}", selector);
       }
@@ -127,12 +116,7 @@ impl Args {
   }
 }
 
-fn collect_selectors(
-  value: &serde_yaml::Value,
-  prefix: &str,
-  selectors: &mut BTreeMap<String, SelectorInfo>,
-  counter: &mut usize,
-) {
+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 {

data/rust/src/commands/sort.rs

@@ -89,13 +89,7 @@ impl Args {
 
     let by = &self.by[0];
     let selector = self.selector.as_deref().unwrap_or("");
-
-    let items_selector = if selector.is_empty() {
-      "[]".to_string()
-    } else {
-      format!("{}[]", selector)
-    };
-
+    let items_selector = if selector.is_empty() { "[]".to_string() } else { format!("{}[]", selector) };
     let document = parse_file(&self.file);
     let (labels, context_values, selector_display) = self.resolve_labels(&document, by, selector, &items_selector);
 
@@ -111,6 +105,7 @@ impl Args {
 
     for (index, label) in labels.iter().enumerate() {
       let context = context_values.get(index).map(|c| c.as_slice()).unwrap_or(&[]);
+
       eprintln!("    {}", self.format_label_line(index, label, context));
     }
 
@@ -119,26 +114,14 @@ impl Args {
     eprintln!("{context_hint}");
     eprintln!();
     eprintln!("  {BOLD}To sort alphabetically:{RESET}");
-    eprintln!(
-      "    yerba sort \"{}\"{selector_display} --by \"{by}\" --order asc",
-      self.file
-    );
-    eprintln!(
-      "    yerba sort \"{}\"{selector_display} --by \"{by}\" --order desc",
-      self.file
-    );
+    eprintln!("    yerba sort \"{}\"{selector_display} --by \"{by}\" --order asc", self.file);
+    eprintln!("    yerba sort \"{}\"{selector_display} --by \"{by}\" --order desc", self.file);
     eprintln!();
     eprintln!("  {BOLD}To reorder explicitly:{RESET}");
-    eprintln!(
-      "    yerba sort \"{}\"{selector_display} --by \"{by}\" --order \"{csv}\"",
-      self.file
-    );
+    eprintln!("    yerba sort \"{}\"{selector_display} --by \"{by}\" --order \"{csv}\"", self.file);
     eprintln!();
     eprintln!("  {BOLD}To move individual items:{RESET}");
-    eprintln!(
-      "    yerba move \"{}\"{selector_display} <item> --before/--after <target>",
-      self.file
-    );
+    eprintln!("    yerba move \"{}\"{selector_display} <item> --before/--after <target>", self.file);
 
     process::exit(1);
   }
@@ -174,11 +157,7 @@ impl Args {
       let mut document = parse_file(&resolved_file);
 
       if sort_fields.is_empty() {
-        let first_item_selector = if selector.is_empty() {
-          "[0]".to_string()
-        } else {
-          format!("{}[0]", selector)
-        };
+        let first_item_selector = if selector.is_empty() { "[0]".to_string() } else { format!("{}[0]", selector) };
 
         match document.get_value(&first_item_selector) {
           Some(first) if first.is_mapping() => {
@@ -190,11 +169,7 @@ impl Args {
             let fields: Vec<&String> = selectors
               .iter()
               .filter(|s| {
-                let check = if prefix.is_empty() {
-                  format!("{}[].", selector)
-                } else {
-                  prefix.to_string()
-                };
+                let check = if prefix.is_empty() { format!("{}[].", selector) } else { prefix.to_string() };
                 s.starts_with(&check) && !s[check.len()..].contains('.') && !s[check.len()..].contains('[')
               })
               .collect();
@@ -212,10 +187,7 @@ impl Args {
           }
 
           None if selector.is_empty() => {
-            eprintln!(
-              "{RED}Error:{RESET} no sequence found at root level in {}",
-              resolved_file
-            );
+            eprintln!("{RED}Error:{RESET} no sequence found at root level in {}", resolved_file);
             eprintln!();
             eprintln!("  {DIM}Specify a selector for the sequence to sort:{RESET}");
             eprintln!("    yerba sort \"{}\" \"<selector>\"", self.file);
@@ -255,11 +227,7 @@ impl Args {
     let order = &self.order[0];
     let selector = self.selector.as_deref().unwrap_or("");
 
-    let items_selector = if selector.is_empty() {
-      "[]".to_string()
-    } else {
-      format!("{}[]", selector)
-    };
+    let items_selector = if selector.is_empty() { "[]".to_string() } else { format!("{}[]", selector) };
 
     let mut document = parse_file(&self.file);
     let mut seen = std::collections::HashSet::new();
@@ -286,11 +254,7 @@ impl Args {
     let values_with_commas: Vec<&String> = labels.iter().filter(|l| l.contains(',')).collect();
 
     if !values_with_commas.is_empty() {
-      let selector_display = if selector.is_empty() {
-        String::new()
-      } else {
-        format!(" \"{selector}\"")
-      };
+      let selector_display = if selector.is_empty() { String::new() } else { format!(" \"{selector}\"") };
 
       eprintln!("{RED}Error:{RESET} some values for {by} contain commas, which conflicts with --order parsing");
       eprintln!();
@@ -302,108 +266,24 @@ impl Args {
 
       eprintln!();
       eprintln!("  {BOLD}Use yerba move to reorder individual items instead:{RESET}");
-      eprintln!(
-        "    yerba move \"{}\"{selector_display} <item> --before/--after <target>",
-        self.file
-      );
+      eprintln!("    yerba move \"{}\"{selector_display} <item> --before/--after <target>", self.file);
 
       process::exit(1);
     }
 
     let desired_order: Vec<&str> = order.split(',').map(|s| s.trim()).collect();
-
-    let mut used = vec![false; labels.len()];
-    let mut moves: Vec<usize> = Vec::new();
-
-    for desired in &desired_order {
-      let found = labels
-        .iter()
-        .enumerate()
-        .find(|(index, label)| label.as_str() == *desired && !used[*index]);
-
-      if let Some((index, _)) = found {
-        moves.push(index);
-        used[index] = true;
-      } else {
-        eprintln!("{RED}Error:{RESET} no item found with {by} == \"{desired}\"");
-        eprintln!();
-        eprintln!("  {BOLD}Available values:{RESET}");
-
-        for (index, label) in labels.iter().enumerate() {
-          eprintln!("    {DIM}{index}:{RESET} {label}");
-        }
-
-        process::exit(1);
-      }
-    }
-
-    let missing: Vec<&String> = labels
-      .iter()
-      .enumerate()
-      .filter(|(index, _)| !used[*index])
-      .map(|(_, label)| label)
-      .collect();
-
-    if !missing.is_empty() {
-      eprintln!(
-        "{RED}Error:{RESET} --order must specify all {} items, but {} are missing",
-        labels.len(),
-        missing.len()
-      );
-      eprintln!();
-      eprintln!("  {BOLD}Missing values:{RESET}");
-
-      for label in &missing {
-        eprintln!("    {label}");
-      }
-
-      eprintln!();
-      eprintln!("  {BOLD}All values (by {by}):{RESET}");
-
-      for label in &labels {
-        eprintln!("    {label}");
-      }
-
-      eprintln!();
-      eprintln!("  {BOLD}To move individual items, use:{RESET}");
-      eprintln!("    yerba move <file> <selector> <item> --before/--after <target>");
-
-      process::exit(1);
-    }
-
     let container = if selector.is_empty() { "" } else { selector };
 
-    for target in 0..moves.len() {
-      let source = moves[target];
-
-      if source != target {
-        let result = document.move_item(container, source, target);
-
-        if let Err(error) = result {
-          eprintln!("{RED}Error:{RESET} {}", error);
-          process::exit(1);
-        }
-
-        for item in moves.iter_mut().skip(target + 1) {
-          if *item >= target && *item < source {
-            *item += 1;
-          } else if *item == source {
-            *item = target;
-          }
-        }
+    match document.reorder_items(container, by, &desired_order) {
+      Ok(()) => output(&self.file, &document, self.dry_run),
+      Err(error) => {
+        eprintln!("{RED}Error:{RESET} {}", error);
+        process::exit(1);
       }
     }
-
-    output(&self.file, &document, self.dry_run);
   }
 
-  fn resolve_labels(
-    &self,
-    document: &yerba::Document,
-    by: &str,
-    selector: &str,
-    items_selector: &str,
-  ) -> (Vec<String>, Vec<Vec<String>>, String) {
+  fn resolve_labels(&self, document: &yerba::Document, by: &str, selector: &str, items_selector: &str) -> (Vec<String>, Vec<Vec<String>>, String) {
     use super::color::*;
 
     let items = document.get_values(items_selector);
@@ -413,10 +293,7 @@ impl Args {
         eprintln!("{RED}Error:{RESET} no sequence found at root level");
         eprintln!();
         eprintln!("  {DIM}If the file is a map, specify which sequence to sort:{RESET}");
-        eprintln!(
-          "    yerba sort \"{}\" \"<selector>\" --by \"{by}\" --order asc",
-          self.file
-        );
+        eprintln!("    yerba sort \"{}\" \"<selector>\" --by \"{by}\" --order asc", self.file);
         eprintln!();
 
         super::show_similar_selectors(&self.file, document, "[]");
@@ -458,10 +335,7 @@ impl Args {
         } else {
           let field = by.strip_prefix('.').unwrap_or(by);
 
-          yerba::json::resolve_select_field(item, field)
-            .as_str()
-            .unwrap_or("")
-            .to_string()
+          yerba::json::resolve_select_field(item, field).as_str().unwrap_or("").to_string()
         }
       })
       .collect();
@@ -487,11 +361,7 @@ impl Args {
       })
       .collect();
 
-    let selector_display = if selector.is_empty() {
-      String::new()
-    } else {
-      format!(" \"{selector}\"")
-    };
+    let selector_display = if selector.is_empty() { String::new() } else { format!(" \"{selector}\"") };
 
     (labels, context_values, selector_display)
   }
@@ -502,12 +372,7 @@ impl Args {
     if context.is_empty() {
       format!("{DIM}[{index}]{RESET} {label}")
     } else {
-      let context = context
-        .iter()
-        .filter(|c| !c.is_empty())
-        .cloned()
-        .collect::<Vec<_>>()
-        .join(", ");
+      let context = context.iter().filter(|c| !c.is_empty()).cloned().collect::<Vec<_>>().join(", ");
 
       if context.is_empty() {
         format!("{DIM}[{index}]{RESET} {label}")

data/rust/src/didyoumean.rs

@@ -10,8 +10,7 @@ pub fn didyoumean(input: &str, list: &[String]) -> Option<String> {
     .map(|item| (item.clone(), levenshtein(&input_lower, &item.to_lowercase())))
     .collect();
 
-  scored
-    .sort_by(|(a_item, a_distance), (b_item, b_distance)| a_distance.cmp(b_distance).then_with(|| a_item.cmp(b_item)));
+  scored.sort_by(|(a_item, a_distance), (b_item, b_distance)| a_distance.cmp(b_distance).then_with(|| a_item.cmp(b_item)));
 
   scored.into_iter().next().map(|(item, _)| item)
 }
@@ -29,8 +28,7 @@ pub fn didyoumean_ranked(input: &str, list: &[String], threshold: usize) -> Vec<
     .filter(|(_, distance)| *distance <= threshold)
     .collect();
 
-  scored
-    .sort_by(|(a_item, a_distance), (b_item, b_distance)| a_distance.cmp(b_distance).then_with(|| a_item.cmp(b_item)));
+  scored.sort_by(|(a_item, a_distance), (b_item, b_distance)| a_distance.cmp(b_distance).then_with(|| a_item.cmp(b_item)));
 
   scored.into_iter().map(|(item, _)| item).collect()
 }

data/rust/src/document/condition.rs

@@ -0,0 +1,139 @@
+use super::*;
+
+impl Document {
+  pub fn filter(&self, dot_path: &str, condition: &str) -> Vec<serde_yaml::Value> {
+    self
+      .navigate_all(dot_path)
+      .iter()
+      .filter(|node| self.evaluate_condition_on_node(node, condition))
+      .map(node_to_yaml_value)
+      .collect()
+  }
+
+  pub(super) fn evaluate_condition_on_node(&self, node: &SyntaxNode, condition: &str) -> bool {
+    let condition = condition.trim();
+
+    let (left, operator, right) = match parse_condition(condition) {
+      Some(parts) => parts,
+      None => return false,
+    };
+
+    let path = crate::selector::Selector::parse(&left);
+
+    if !path.is_relative() {
+      return false;
+    }
+
+    let target_nodes = navigate_from_node(node, &path.to_selector_string());
+    let values: Vec<String> = target_nodes.iter().filter_map(extract_scalar_text).collect();
+
+    match operator {
+      "==" => values.iter().any(|value| value == &right),
+      "!=" => values.iter().all(|value| value != &right),
+      "contains" => {
+        if values.iter().any(|value| value == &right || value.contains(&right)) {
+          return true;
+        }
+
+        for node in &target_nodes {
+          if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
+            for entry in sequence.entries() {
+              if let Some(text) = entry.flow().and_then(|flow| extract_scalar_text(flow.syntax())) {
+                if text == right {
+                  return true;
+                }
+              }
+            }
+          }
+        }
+
+        false
+      }
+      "not_contains" => {
+        for node in &target_nodes {
+          if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
+            for entry in sequence.entries() {
+              if let Some(text) = entry.flow().and_then(|flow| extract_scalar_text(flow.syntax())) {
+                if text == right {
+                  return false;
+                }
+              }
+            }
+          }
+        }
+
+        !values.iter().any(|value| value == &right || value.contains(&right))
+      }
+      _ => false,
+    }
+  }
+
+  pub fn evaluate_condition(&self, parent_path: &str, condition: &str) -> bool {
+    let condition = condition.trim();
+
+    let (left, operator, right) = match parse_condition(condition) {
+      Some(parts) => parts,
+      None => return false,
+    };
+
+    let path = crate::selector::Selector::parse(&left);
+
+    let full_path = if path.is_relative() {
+      let path_string = path.to_selector_string();
+
+      if parent_path.is_empty() {
+        path_string
+      } else {
+        format!("{}.{}", parent_path, path_string)
+      }
+    } else {
+      path.to_selector_string()
+    };
+
+    let has_brackets = crate::selector::Selector::parse(&full_path).has_brackets();
+
+    match operator {
+      "==" => {
+        if has_brackets {
+          self.get_all(&full_path).iter().any(|value| value == &right)
+        } else {
+          self.get(&full_path).unwrap_or_default() == right
+        }
+      }
+      "!=" => {
+        if has_brackets {
+          self.get_all(&full_path).iter().all(|value| value != &right)
+        } else {
+          self.get(&full_path).unwrap_or_default() != right
+        }
+      }
+      "contains" => {
+        if has_brackets {
+          self.get_all(&full_path).iter().any(|value| value == &right || value.contains(&right))
+        } else {
+          let items = self.get_sequence_values(&full_path);
+
+          if !items.is_empty() {
+            items.iter().any(|item| item == &right)
+          } else {
+            self.get(&full_path).map(|value| value.contains(&right)).unwrap_or(false)
+          }
+        }
+      }
+      "not_contains" => {
+        if has_brackets {
+          self.get_all(&full_path).iter().all(|value| value != &right && !value.contains(&right))
+        } else {
+          let items = self.get_sequence_values(&full_path);
+
+          if !items.is_empty() {
+            !items.iter().any(|item| item == &right)
+          } else {
+            self.get(&full_path).map(|value| !value.contains(&right)).unwrap_or(true)
+          }
+        }
+      }
+      _ => false,
+    }
+  }
+}