yerba 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef6a9038318ee4d534952892c7893d4deffc0980da76ad2967996ade55c5c4ed
-  data.tar.gz: 4c8ae4131876cbbefdfe0ab13bb2c8624161f07332e05dea0287f4a5eb313040
+  metadata.gz: a769e82895bc0bea8b8e25391f39cdbf8e915a46d524efd05af951738b4b046a
+  data.tar.gz: 83d41f698f888f6065729b8adb5e6646e14b9832871eafde6af2fa60bfd4b862
 SHA512:
-  metadata.gz: c8bbc570ef74e8ec8b63cf97ed16d3cd1497ad9d7a77a9b09ace07b3418c9e8f592bcccad2929f33341ecb547411ea2cb3387f905963b86bd5c37e324ff5931f
-  data.tar.gz: 751785bf9a917245bf914e30cbf0b2bbcf1608be37c3a3d573a94e1f27fbab8fc245d2fc16efae0582e22e670aa5437975fda12bf8075ec15fc6249f697f0dd3
+  metadata.gz: 64e3fe5431316bc5faf03187419f234f52c9d8f04710d06afdd6bf13dc5342a80dadae3a4345ee610f4f307976d45520f0cc6b4bcc7a7959e21a9902ae071343
+  data.tar.gz: 3f12d6fa79ed13905bca60481eb3a87caffa46fd8205b6a9d56a8fcf250ce708698e218a4cec7126294940eb6ce8f44e02abf445144c12b9f39ad16f417a1da7

data/lib/yerba/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yerba
-  VERSION = "0.8.0"
+  VERSION = "0.8.1"
 end

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.8.0"
+version = "0.8.1"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"
@@ -18,21 +18,30 @@ crate-type = ["cdylib", "staticlib", "rlib"]
 [[bin]]
 name = "yerba"
 path = "src/main.rs"
+required-features = ["cli"]
+
+[features]
+default = ["cli"]
+cli = ["dep:clap", "dep:indoc", "dep:anstyle-query", "glob", "schema"]
+glob = ["dep:glob", "dep:rayon"]
+schema = ["dep:jsonschema"]
 
 [dependencies]
 yaml_parser = "0.3"
 rowan = "0.16"
-glob = "0.3"
+glob = { version = "0.3", optional = true }
 serde = { version = "1", features = ["derive"] }
 yaml_serde = "0.10"
 serde_json = { version = "1", features = ["preserve_order"] }
-clap = { version = "4", features = ["derive"] }
-indoc = "2"
-rayon = "1"
-jsonschema = "0.29"
+clap = { version = "4", features = ["derive"], optional = true }
+anstyle-query = { version = "1", optional = true }
+indoc = { version = "2", optional = true }
+rayon = { version = "1", optional = true }
+jsonschema = { version = "0.29", default-features = false, optional = true }
 
 [build-dependencies]
 cbindgen = "0.28"
 
 [dev-dependencies]
+indoc = "2"
 tempfile = "3"

data/rust/src/commands/blank_lines.rs

@@ -37,9 +37,9 @@ impl Args {
     } else if let Ok(count) = self.first.parse::<usize>() {
       ("", count)
     } else {
-      use super::color::*;
+      use super::ui;
 
-      eprintln!("{RED}Error:{RESET} expected a number for blank line count, got '{}'", self.first);
+      eprintln!("{} expected a number for blank line count, got '{}'", ui::failure("Error:"), self.first);
 
       std::process::exit(1);
     };

data/rust/src/commands/directives.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::sync::LazyLock;
 
 use indoc::indoc;
@@ -35,14 +36,13 @@ pub struct Args {
 impl Args {
   pub fn run(self) {
     if !self.ensure && !self.remove {
-      use super::color::*;
-      eprintln!("{RED}Error:{RESET} specify --ensure or --remove");
+      use super::ui;
+      eprintln!("{} specify --ensure or --remove", ui::failure("Error:"));
       std::process::exit(1);
     }
 
     if self.ensure && self.remove {
-      use super::color::*;
-      eprintln!("{RED}Error:{RESET} --ensure and --remove are mutually exclusive");
+      eprintln!("{} --ensure and --remove are mutually exclusive", ui::failure("Error:"));
       std::process::exit(1);
     }
 

data/rust/src/commands/get.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::process;
 use std::sync::LazyLock;
 
@@ -64,9 +65,9 @@ impl Args {
 
     if let Some(condition) = &normalized_condition {
       if let Err(error) = yerba::validate_item_condition(condition) {
-        use super::color::*;
+        use super::ui;
 
-        eprintln!("{RED}Error:{RESET} {}", error);
+        eprintln!("{} {}", ui::failure("Error:"), error);
 
         process::exit(1);
       }
@@ -85,9 +86,7 @@ impl Args {
           continue;
         }
 
-        use super::color::*;
-
-        eprintln!("{RED}Error:{RESET} selector \"{}\" not found in {}", self.selector, self.file);
+        eprintln!("{} selector \"{}\" not found in {}", ui::failure("Error:"), self.selector, self.file);
 
         show_similar_selectors(&self.file, &document, &self.selector);
         process::exit(1);
@@ -110,8 +109,7 @@ impl Args {
               break;
             }
 
-            use super::color::*;
-            eprintln!("{RED}Error:{RESET} select field \"{}\" not found in {}", field.trim(), self.file);
+            eprintln!("{} select field \"{}\" not found in {}", ui::failure("Error:"), field.trim(), self.file);
             show_similar_selectors(&self.file, &document, &full_selector);
             process::exit(1);
           }
@@ -190,10 +188,9 @@ impl Args {
     }
 
     if is_glob && all_results.is_empty() && normalized_condition.is_none() {
-      use super::color::*;
-
       eprintln!(
-        "{RED}Error:{RESET} selector \"{}\" not found in any of the {} files matching \"{}\"",
+        "{} selector \"{}\" not found in any of the {} files matching \"{}\"",
+        ui::failure("Error:"),
         self.selector,
         files.len(),
         self.file

data/rust/src/commands/init.rs

@@ -3,13 +3,13 @@ use std::process;
 
 use indoc::indoc;
 
-use super::color::*;
+use super::ui;
 
 pub fn run() {
   let filename = "Yerbafile";
 
   if Path::new(filename).exists() {
-    eprintln!("🧉 {YELLOW}{BOLD}Yerbafile already exists.{RESET}");
+    eprintln!("🧉 {}", ui::pending("Yerbafile already exists."));
     process::exit(1);
   }
 
@@ -81,9 +81,9 @@ pub fn run() {
   "#};
 
   std::fs::write(filename, content).unwrap_or_else(|error| {
-    eprintln!("{RED}Error:{RESET} writing Yerbafile: {}", error);
+    eprintln!("{} writing Yerbafile: {}", ui::failure("Error:"), error);
     process::exit(1);
   });
 
-  eprintln!("🧉 {GREEN}{BOLD}Created Yerbafile{RESET}");
+  eprintln!("🧉 {}", ui::success("Created Yerbafile"));
 }

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) {