yerba 0.7.6-arm-linux-gnu → 0.8.1-arm-linux-gnu

data/rust/src/commands/insert.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::sync::LazyLock;
 
 use indoc::indoc;
@@ -28,6 +29,7 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
 pub struct Args {
   file: String,
   selector: String,
+  #[arg(allow_hyphen_values = true)]
   value: Option<String>,
   #[arg(long, help = "Read value from a file (use - for stdin)")]
   from: Option<String>,
@@ -49,8 +51,8 @@ impl Args {
         let mut buffer = String::new();
 
         std::io::stdin().read_to_string(&mut buffer).unwrap_or_else(|error| {
-          use super::color::*;
-          eprintln!("{RED}Error:{RESET} reading stdin: {}", error);
+          use super::ui;
+          eprintln!("{} reading stdin: {}", ui::failure("Error:"), error);
 
           std::process::exit(1);
         });
@@ -59,8 +61,7 @@ impl Args {
       } else {
         std::fs::read_to_string(&from_path)
           .unwrap_or_else(|error| {
-            use super::color::*;
-            eprintln!("{RED}Error:{RESET} reading {}: {}", from_path, error);
+            eprintln!("{} reading {}: {}", ui::failure("Error:"), from_path, error);
             std::process::exit(1);
           })
           .trim()
@@ -69,8 +70,7 @@ impl Args {
     } else if let Some(val) = self.value {
       val
     } else {
-      use super::color::*;
-      eprintln!("{RED}Error:{RESET} either a value argument or --from is required");
+      eprintln!("{} either a value argument or --from is required", ui::failure("Error:"));
 
       std::process::exit(1);
     };

data/rust/src/commands/location.rs

@@ -28,13 +28,13 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    use super::color::*;
+    use super::ui;
 
     let document = parse_file(&self.file);
     let info = document.get_node_info(&self.selector);
 
     if info.location.start_line == 0 && info.location.end_line == 0 {
-      eprintln!("{RED}Error:{RESET} selector \"{}\" not found in {}", self.selector, self.file);
+      eprintln!("{} selector \"{}\" not found in {}", ui::failure("Error:"), self.selector, self.file);
 
       super::show_similar_selectors(&self.file, &document, &self.selector);
       process::exit(1);

data/rust/src/commands/mate.rs

@@ -1,12 +1,12 @@
-use super::color::*;
+use super::ui;
 
 pub fn run() {
-  let g = GREEN;
-  let b = BOLD;
-  let d = DIM;
-  let i = "\x1b[3m"; // italic
-  let y = YELLOW;
-  let r = RESET;
+  let g = ui::raw::green();
+  let b = ui::raw::bold();
+  let d = ui::raw::dim();
+  let i = ui::raw::italic();
+  let y = ui::raw::yellow();
+  let r = ui::raw::reset();
   let hr = format!("    {d}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}{r}");
 
   println!();

data/rust/src/commands/mod.rs

@@ -18,6 +18,7 @@ pub mod selectors;
 pub mod set;
 pub mod sort;
 pub mod sort_keys;
+pub mod ui;
 pub mod unique;
 pub mod version;
 
@@ -30,56 +31,15 @@ pub(crate) fn is_github_actions() -> bool {
   std::env::var("GITHUB_ACTIONS").is_ok()
 }
 
-pub(crate) mod color {
-  pub const GREEN: &str = "\x1b[32m";
-  pub const RED: &str = "\x1b[31m";
-  pub const YELLOW: &str = "\x1b[33m";
-  pub const DIM: &str = "\x1b[2m";
-  pub const BOLD: &str = "\x1b[1m";
-  pub const RESET: &str = "\x1b[0m";
+pub(crate) fn pluralize(count: usize, singular: &str, plural: &str) -> String {
+  format!("{} {}", count, if count == 1 { singular } else { plural })
 }
 
-// Compile-time ANSI macros for use in concat!() / clap attributes (used in main.rs)
-#[allow(unused_macros)]
-macro_rules! h {
-  () => {
-    "\x1b[1;32m"
-  };
-} // header (bold green)
-#[allow(unused_macros)]
-macro_rules! b {
-  () => {
-    "\x1b[1m"
-  };
-} // bold
-#[allow(unused_macros)]
-macro_rules! c {
-  () => {
-    "\x1b[36m"
-  };
-} // cyan
-#[allow(unused_macros)]
-macro_rules! d {
-  () => {
-    "\x1b[2m"
-  };
-} // dim
-#[allow(unused_macros)]
-macro_rules! r {
-  () => {
-    "\x1b[0m"
-  };
-} // reset
-#[allow(unused_imports)]
-pub(crate) use {b, c, d, h, r};
-
 pub(crate) fn colorize_examples(input: &str) -> String {
   colorize_help(&format!("Examples:\n{}", input.trim()))
 }
 
 pub(crate) fn colorize_help(input: &str) -> String {
-  use color::*;
-
   let mut output = String::new();
 
   for line in input.lines() {
@@ -91,7 +51,7 @@ pub(crate) fn colorize_help(input: &str) -> String {
     }
 
     if trimmed.ends_with(':') && !trimmed.contains(' ') {
-      output.push_str(&format!("{GREEN}{BOLD}{trimmed}{RESET}\n"));
+      output.push_str(&format!("{}\n", ui::success(trimmed)));
       continue;
     }
 
@@ -100,11 +60,11 @@ pub(crate) fn colorize_help(input: &str) -> String {
 
       match (parts.next(), parts.next(), parts.next()) {
         (Some(cmd), Some(sub), Some(rest)) => {
-          output.push_str(&format!("  {BOLD}{cmd}{RESET} \x1b[36m{sub}{RESET} {rest}\n"));
+          output.push_str(&format!("  {} {} {}\n", ui::strong(cmd), ui::muted(sub), rest));
         }
 
         (Some(cmd), Some(sub), None) => {
-          output.push_str(&format!("  {BOLD}{cmd}{RESET} \x1b[36m{sub}{RESET}\n"));
+          output.push_str(&format!("  {} {}\n", ui::strong(cmd), ui::muted(sub)));
         }
 
         _ => {
@@ -134,9 +94,14 @@ 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!(
+        "  {} {:<21} {}\n",
+        ui::muted(format!("{:<20}", columns[0])),
+        columns[1],
+        ui::subtle(columns[2])
+      ));
     } else if columns.len() == 2 {
-      output.push_str(&format!("  \x1b[36m{:<20}{RESET} {}\n", columns[0], columns[1]));
+      output.push_str(&format!("  {} {}\n", ui::muted(format!("{:<20}", columns[0])), columns[1]));
     } else {
       output.push_str(&format!("  {trimmed}\n"));
     }
@@ -204,19 +169,35 @@ impl Command {
 }
 
 pub(crate) fn run_yerbafile(write: bool, files: Vec<String>) {
-  use color::*;
-
   let yerbafile_path = yerba::Yerbafile::find().unwrap_or_else(|| {
-    eprintln!("{RED}No Yerbafile found.{RESET} Run {BOLD}yerba init{RESET} to create one.");
+    eprintln!(
+      "{} No Yerbafile found. Run {} to create one.",
+      ui::failure(ui::glyph::FAIL),
+      ui::strong("yerba init")
+    );
     process::exit(1);
   });
 
   let yerbafile = yerba::Yerbafile::load(&yerbafile_path).unwrap_or_else(|error| {
-    eprintln!("{RED}Error loading {}:{RESET} {}", yerbafile_path.display(), error);
+    eprintln!(
+      "{} {}",
+      ui::failure(ui::glyph::FAIL),
+      ui::strong(format!("Could not read {}", yerbafile_path.display()))
+    );
+    eprintln!("  {}", error);
     process::exit(1);
   });
 
-  eprintln!("🧉 {BOLD}Using{RESET} {}", yerbafile_path.display());
+  eprintln!("{}", ui::banner());
+
+  eprintln!(
+    "{}{} {}\n",
+    ui::INDENT,
+    ui::strong("Using Yerbafile rules"),
+    ui::subtle(format!("(from {})", yerbafile_path.display()))
+  );
+
+  let started = std::time::Instant::now();
 
   let results = if files.is_empty() {
     yerbafile.apply(write)
@@ -224,6 +205,8 @@ pub(crate) fn run_yerbafile(write: bool, files: Vec<String>) {
     files.iter().flat_map(|file| yerbafile.apply_file(file, write)).collect()
   };
 
+  let elapsed = started.elapsed();
+
   let mut has_changes = false;
   let mut has_errors = false;
 
@@ -231,7 +214,8 @@ pub(crate) fn run_yerbafile(write: bool, files: Vec<String>) {
 
   for result in &results {
     if let Some(error) = &result.error {
-      eprintln!("  {RED}error:{RESET} {} {DIM}—{RESET} {}", result.file, error);
+      eprintln!("  {} {}", ui::failure(ui::glyph::FAIL), ui::strong(&result.file));
+      eprintln!("    {}", ui::muted(error));
 
       if github {
         use yerba::error::GitHubAnnotations;
@@ -244,12 +228,15 @@ pub(crate) fn run_yerbafile(write: bool, files: Vec<String>) {
       has_errors = true;
     } else if result.changed {
       if write {
-        eprintln!("  {GREEN}updated:{RESET} {}", result.file);
+        eprintln!("  {} {}", ui::success(ui::glyph::OK), result.file);
       } else {
-        eprintln!("  {YELLOW}would change:{RESET} {}", result.file);
+        eprintln!("  {} {}", ui::pending(ui::glyph::PENDING), result.file);
 
         if github {
-          eprintln!("::error file={}::File does not match Yerbafile rules", result.file);
+          eprintln!(
+            "::error file={}::File does not match Yerbafile rules. Run `yerba apply` to update it.",
+            result.file
+          );
         }
       }
 
@@ -257,19 +244,70 @@ pub(crate) fn run_yerbafile(write: bool, files: Vec<String>) {
     }
   }
 
-  if !has_changes && !has_errors {
-    eprintln!("\n{BOLD}{GREEN}All files match the rules.{RESET}");
+  let changed = results.iter().filter(|result| result.error.is_none() && result.changed).count();
+  let seen: std::collections::HashSet<&String> = results.iter().map(|result| &result.file).collect();
+  let rules = yerbafile.rules.len() + usize::from(!yerbafile.pipeline.is_empty());
+  let steps = yerbafile.pipeline.len() + yerbafile.rules.iter().map(|rule| rule.pipeline.len()).sum::<usize>();
+
+  if seen.is_empty() {
+    eprintln!(
+      "{} {} {}",
+      ui::pending(ui::glyph::PENDING),
+      ui::pending("No files matched."),
+      ui::subtle("Check the `files:` patterns in your Yerbafile.")
+    );
+  } else if !has_changes && !has_errors {
+    eprintln!("{} {}", ui::success(ui::glyph::OK), ui::success("Everything's up to date."));
+  }
+
+  if write && has_changes {
+    eprintln!(
+      "\n{} {}",
+      ui::success(ui::glyph::OK),
+      ui::success(format!("Freshly brewed {}.", pluralize(changed, "file", "files")))
+    );
   }
 
   if !write && has_changes {
-    process::exit(1);
+    let command = if files.is_empty() {
+      "yerba apply".to_string()
+    } else {
+      format!("yerba apply {}", files.join(" "))
+    };
+
+    eprintln!(
+      "\n{} {} {}",
+      ui::pending(ui::glyph::PENDING),
+      ui::pending(format!("{} out of date.", pluralize(changed, "file", "files"))),
+      ui::subtle(format!("Run {} to update {}.", command, if changed == 1 { "it" } else { "them" }))
+    );
   }
 
-  if has_errors {
+  eprintln!(
+    "{}{}",
+    ui::STATUS_INDENT,
+    ui::subtle(format!(
+      "{} · {} · {} · {}",
+      pluralize(seen.len(), "file", "files"),
+      pluralize(rules, "rule", "rules"),
+      pluralize(steps, "step", "steps"),
+      format_duration(elapsed)
+    ))
+  );
+
+  if has_errors || (!write && has_changes) {
     process::exit(1);
   }
 }
 
+fn format_duration(elapsed: std::time::Duration) -> String {
+  if elapsed.as_secs() == 0 {
+    format!("{}ms", elapsed.as_millis())
+  } else {
+    format!("{:.1}s", elapsed.as_secs_f64())
+  }
+}
+
 pub(crate) fn resolve_move_indexes(
   document: &yerba::Document,
   path: &str,
@@ -279,10 +317,8 @@ pub(crate) fn resolve_move_indexes(
   to: Option<usize>,
   resolve: impl Fn(&yerba::Document, &str, &str) -> Result<usize, yerba::YerbaError>,
 ) -> (usize, usize) {
-  use color::*;
-
   let from_index = resolve(document, path, item).unwrap_or_else(|error| {
-    eprintln!("{RED}Error:{RESET} {}", error);
+    eprintln!("{} {}", ui::failure("Error:"), error);
     process::exit(1);
   });
 
@@ -290,7 +326,7 @@ pub(crate) fn resolve_move_indexes(
     index
   } else if let Some(target) = &before {
     let target_index = resolve(document, path, target).unwrap_or_else(|error| {
-      eprintln!("{RED}Error:{RESET} {}", error);
+      eprintln!("{} {}", ui::failure("Error:"), error);
       process::exit(1);
     });
 
@@ -301,7 +337,7 @@ pub(crate) fn resolve_move_indexes(
     }
   } else if let Some(target) = &after {
     let target_index = resolve(document, path, target).unwrap_or_else(|error| {
-      eprintln!("{RED}Error:{RESET} {}", error);
+      eprintln!("{} {}", ui::failure("Error:"), error);
       process::exit(1);
     });
 
@@ -311,7 +347,7 @@ pub(crate) fn resolve_move_indexes(
       target_index + 1
     }
   } else {
-    eprintln!("{RED}Error:{RESET} specify --before, --after, or --to");
+    eprintln!("{} specify --before, --after, or --to", ui::failure("Error:"));
     process::exit(1);
   };
 
@@ -319,12 +355,10 @@ pub(crate) fn resolve_move_indexes(
 }
 
 pub(crate) fn resolve_files(pattern: &str) -> Vec<String> {
-  use color::*;
-
   if pattern.contains('*') || pattern.contains('?') || pattern.contains('[') {
     let paths: Vec<String> = glob::glob(pattern)
       .unwrap_or_else(|error| {
-        eprintln!("{RED}Error:{RESET} invalid glob pattern '{}': {}", pattern, error);
+        eprintln!("{} invalid glob pattern '{}': {}", ui::failure("Error:"), pattern, error);
         process::exit(1);
       })
       .filter_map(|entry| entry.ok())
@@ -332,7 +366,7 @@ pub(crate) fn resolve_files(pattern: &str) -> Vec<String> {
       .collect();
 
     if paths.is_empty() {
-      eprintln!("{RED}Error:{RESET} no files matched pattern: {}", pattern);
+      eprintln!("{} no files matched pattern: {}", ui::failure("Error:"), pattern);
       process::exit(1);
     }
 
@@ -343,18 +377,16 @@ pub(crate) fn resolve_files(pattern: &str) -> Vec<String> {
 }
 
 pub(crate) fn parse_file(file: &str) -> yerba::Document {
-  use color::*;
-
   yerba::parse_file(file).unwrap_or_else(|error| {
     match &error {
       yerba::YerbaError::IoError(io_error) => match io_error.kind() {
-        std::io::ErrorKind::NotFound => eprintln!("{RED}Error:{RESET} file not found: {}", file),
+        std::io::ErrorKind::NotFound => eprintln!("{} file not found: {}", ui::failure("Error:"), file),
         std::io::ErrorKind::PermissionDenied => {
-          eprintln!("{RED}Error:{RESET} permission denied: {}", file)
+          eprintln!("{} permission denied: {}", ui::failure("Error:"), file)
         }
-        _ => eprintln!("{RED}Error:{RESET} reading {}: {}", file, io_error),
+        _ => eprintln!("{} reading {}: {}", ui::failure("Error:"), file, io_error),
       },
-      _ => eprintln!("{RED}Error:{RESET} parsing {}: {}", file, error),
+      _ => eprintln!("{} parsing {}: {}", ui::failure("Error:"), file, error),
     }
 
     process::exit(1);
@@ -366,21 +398,19 @@ pub(crate) fn run_op(display_file: &str, document: &yerba::Document, result: Res
 }
 
 pub(crate) fn run_op_with_hint(display_file: &str, document: &yerba::Document, result: Result<(), yerba::YerbaError>, hint: Option<&str>) {
-  use color::*;
-
   if let Err(error) = result {
     if let yerba::YerbaError::SelectorNotFound(selector) = &error {
-      eprintln!("{RED}Error:{RESET} selector \"{selector}\" not found in {display_file}");
+      eprintln!("{} selector \"{selector}\" not found in {display_file}", ui::failure("Error:"));
 
       show_similar_selectors(display_file, document, selector);
     } else {
-      eprintln!("{RED}Error:{RESET} {}", error);
+      eprintln!("{} {}", ui::failure("Error:"), error);
     }
 
     if let Some(hint) = hint {
       if matches!(error, yerba::YerbaError::SelectorNotFound(_)) {
         eprintln!();
-        eprintln!("  {DIM}Hint: {hint}{RESET}");
+        eprintln!("  {}", ui::subtle(format!("Hint: {}", hint)));
       }
     }
 
@@ -389,7 +419,6 @@ pub(crate) fn run_op_with_hint(display_file: &str, document: &yerba::Document, r
 }
 
 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();
@@ -405,19 +434,19 @@ pub(crate) fn show_similar_selectors(file: &str, document: &yerba::Document, inv
   eprintln!();
 
   if close.is_empty() {
-    eprintln!("  {BOLD}Available selectors in {file}:{RESET}");
+    eprintln!("  {}", ui::strong(format!("Available selectors in {}:", file)));
 
     for selector in selectors.iter().take(10) {
-      eprintln!("    {DIM}{selector}{RESET}");
+      eprintln!("    {}", ui::subtle(selector));
     }
 
     if selectors.len() > 10 {
-      eprintln!("    {DIM}... and {} more{RESET}", selectors.len() - 10);
+      eprintln!("    {}", ui::subtle(format!("... and {} more", selectors.len() - 10)));
     }
   } else if close.len() == 1 {
-    eprintln!("  {BOLD}Did you mean this selector?{RESET} {}", close[0]);
+    eprintln!("  {} {}", ui::strong("Did you mean this selector?"), close[0]);
   } else {
-    eprintln!("  {BOLD}Did you mean one of these selectors?{RESET}");
+    eprintln!("  {}", ui::strong("Did you mean one of these selectors?"));
 
     for selector in close.iter().take(5) {
       eprintln!("    {selector}");
@@ -425,8 +454,8 @@ pub(crate) fn show_similar_selectors(file: &str, document: &yerba::Document, inv
   }
 
   eprintln!();
-  eprintln!("  {BOLD}To see all valid selectors, run:{RESET}");
-  eprintln!("    yerba selectors \"{file}\"{RESET}");
+  eprintln!("  {}", ui::strong("To see all valid selectors, run:"));
+  eprintln!("    yerba selectors \"{file}\"");
 }
 
 pub(crate) fn output(file: &str, document: &yerba::Document, dry_run: bool) {

data/rust/src/commands/move_key.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::process;
 use std::sync::LazyLock;
 
@@ -43,10 +44,11 @@ impl Args {
       let (target_parent, target_key) = target.rsplit_once('.').unwrap_or(("", &target));
 
       if target_parent != parent_path {
-        use super::color::*;
         eprintln!(
-          "{RED}Error:{RESET} cannot move key across different maps ({} \u{2192} {})\n\n  Use 'yerba rename' to relocate keys to a different path.",
-          self.selector, target
+          "{} cannot move key across different maps ({} \u{2192} {})\n\n  Use 'yerba rename' to relocate keys to a different path.",
+          ui::failure("Error:"),
+          self.selector,
+          target
         );
 
         process::exit(1);
@@ -59,10 +61,11 @@ impl Args {
       let (target_parent, target_key) = target.rsplit_once('.').unwrap_or(("", &target));
 
       if target_parent != parent_path {
-        use super::color::*;
         eprintln!(
-          "{RED}Error:{RESET} cannot move key across different maps ({} \u{2192} {})\n\n  Use 'yerba rename' to relocate keys to a different path.",
-          self.selector, target
+          "{} cannot move key across different maps ({} \u{2192} {})\n\n  Use 'yerba rename' to relocate keys to a different path.",
+          ui::failure("Error:"),
+          self.selector,
+          target
         );
 
         process::exit(1);

data/rust/src/commands/quote_style.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::sync::LazyLock;
 
 use indoc::indoc;
@@ -38,8 +39,8 @@ pub struct Args {
 impl Args {
   pub fn run(self) {
     if self.values.is_none() && self.keys.is_none() {
-      use super::color::*;
-      eprintln!("{RED}Error:{RESET} specify --values, --keys, or both");
+      use super::ui;
+      eprintln!("{} specify --values, --keys, or both", ui::failure("Error:"));
       std::process::exit(1);
     }
 
@@ -55,9 +56,7 @@ impl Args {
       if let Some(style) = &self.values {
         if let Ok(warnings) = document.enforce_quotes_at(style, selector) {
           for warning in warnings {
-            use super::color::*;
-
-            eprintln!("{YELLOW}Warning:{RESET} {} — {}", resolved_file, warning);
+            eprintln!("{} {} — {}", ui::pending("Warning:"), resolved_file, warning);
           }
         }
       }

data/rust/src/commands/rename.rs

@@ -8,15 +8,15 @@ use super::{output, parse_file, resolve_files, run_op};
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
     yerba rename config.yml "database.host" "database.hostname"
-    yerba rename config.yml "database.host" "hostname"
-    yerba rename config.yml "database.host" "settings.db_host"
     yerba rename videos.yml "[0].old_name" "[0].name"
+    yerba rename config.yml "database.host" "settings.db_host"  # moves the key to another map
+    yerba rename config.yml "database.host" "hostname"          # moves the key to the document root
   "#})
 });
 
 #[derive(clap::Args)]
 #[command(
-  about = "Rename a key in a map (preserves value and position)",
+  about = "Rename a key, or move it to another map (the destination is a full selector path)",
   arg_required_else_help = true,
   after_help = EXAMPLES.as_str()
 )]

data/rust/src/commands/schema.rs

@@ -1,7 +1,7 @@
 use std::process;
 
-use super::color::*;
 use super::resolve_files;
+use super::ui;
 
 #[derive(clap::Args)]
 #[command(
@@ -32,7 +32,7 @@ impl Args {
     let schema = match yerba::schema::load_schema(&self.schema) {
       Ok(schema) => schema,
       Err(error) => {
-        eprintln!("{RED}Error:{RESET} {}", error);
+        eprintln!("{} {}", ui::failure("Error:"), error);
         process::exit(1);
       }
     };
@@ -40,7 +40,7 @@ impl Args {
     let files = resolve_files(&self.file);
 
     if files.is_empty() {
-      eprintln!("{RED}Error:{RESET} no files matching: {}", self.file);
+      eprintln!("{} no files matching: {}", ui::failure("Error:"), self.file);
       process::exit(1);
     }
 
@@ -51,7 +51,7 @@ impl Args {
       let document = match yerba::Document::parse_file(file) {
         Ok(document) => document,
         Err(error) => {
-          eprintln!("  {RED}error:{RESET} {} {DIM}—{RESET} {}", file, error);
+          eprintln!("  {} {} {} {}", ui::failure("error:"), ui::subtle("—"), file, error);
           has_errors = true;
           continue;
         }
@@ -66,7 +66,7 @@ impl Args {
       has_errors = true;
 
       let relative = file.strip_prefix("./").unwrap_or(file);
-      eprintln!("  {RED}error:{RESET} {relative}");
+      eprintln!("  {} {relative}", ui::failure("error:"));
 
       for error in &errors {
         eprintln!("    {error}");
@@ -78,7 +78,7 @@ impl Args {
     if has_errors {
       process::exit(1);
     } else {
-      eprintln!("{GREEN}All {count} files valid.{RESET}", count = files.len());
+      eprintln!("{}", ui::success(format!("All {} files valid.", files.len())));
     }
   }
 }

data/rust/src/commands/selectors.rs

@@ -4,7 +4,7 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{color, parse_file, resolve_files};
+use super::{parse_file, resolve_files, ui};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
@@ -108,7 +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), ui::subtle(label));
       } else {
         println!("{}", selector);
       }

data/rust/src/commands/set.rs

@@ -25,6 +25,7 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
 pub struct Args {
   file: String,
   selector: String,
+  #[arg(allow_hyphen_values = true)]
   value: String,
   #[arg(long)]
   if_exists: bool,
@@ -42,6 +43,16 @@ impl Args {
   pub fn run(self) {
     let parent_path = self.selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
+    if let Some(condition) = &self.condition {
+      if let Err(error) = yerba::validate_condition(condition) {
+        use super::ui;
+
+        eprintln!("{} {}", ui::failure("Error:"), error);
+
+        std::process::exit(1);
+      }
+    }
+
     for resolved_file in resolve_files(&self.file) {
       let mut document = parse_file(&resolved_file);
 
@@ -50,7 +61,7 @@ impl Args {
       } else if self.if_missing {
         !document.exists(&self.selector)
       } else if let Some(condition) = &self.condition {
-        document.evaluate_condition(parent_path, condition)
+        document.evaluate_condition(parent_path, condition).unwrap_or(false)
       } else {
         true
       };