yerba 0.8.0-arm-linux-gnu → 0.9.0-arm-linux-gnu

data/rust/src/commands/insert.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::sync::LazyLock;
 
 use indoc::indoc;
@@ -7,13 +8,13 @@ use super::{output, parse_file, resolve_files, run_op};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
-    yerba insert config.yml "database.ssl" true
-    yerba insert config.yml "database.ssl" true --after "host"
-    yerba insert config.yml "database.ssl" true --before "port"
+    yerba insert config.yml "database.ssl" true --plain
+    yerba insert config.yml "database.ssl" true --plain --after "host"
+    yerba insert config.yml "database.ssl" true --plain --before "port"
     yerba insert config.yml "tags" "yaml"
     yerba insert config.yml "tags" "yaml" --at 0
     yerba insert config.yml "tags" "yaml" --after "ruby"
-    yerba insert speakers.yml "" "name: Bob" --after ".name == Alice"
+    yerba insert speakers.yml "" "name: Bob" --plain --after ".name == Alice"
     yerba insert videos.yml "[0].speakers" "Diana" --before ".name == Charlie"
     yerba insert videos.yml "" --from "new_talk.yml" --after ".id == first-talk"
   "#})
@@ -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>,
@@ -37,6 +39,8 @@ pub struct Args {
   after: Option<String>,
   #[arg(long)]
   at: Option<usize>,
+  #[arg(long, help = "Write the value as raw YAML, for literals like null, true or 42 and for map or sequence fragments")]
+  plain: bool,
   #[arg(long)]
   dry_run: bool,
 }
@@ -49,8 +53,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,18 +63,20 @@ 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()
           .to_string()
       }
-    } else if let Some(val) = self.value {
-      val
+    } else if let Some(value) = self.value {
+      if self.plain {
+        value
+      } else {
+        yerba::quote_scalar(&value)
+      }
     } 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,34 @@ 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!("\n{}\n", ui::banner());
+
+  eprintln!(
+    "{} {}\n",
+    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 +204,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 +213,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 +227,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 +243,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 +316,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 +325,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 +336,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 +346,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 +354,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 +365,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 +376,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 +397,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 +418,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 +433,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 +453,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/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);
       }