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

data/rust/src/commands/sort.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::process;
 use std::sync::LazyLock;
 
@@ -53,14 +54,14 @@ fn is_explicit_reorder(orders: &[String]) -> bool {
 
 impl Args {
   pub fn run(self) {
-    use super::color::*;
+    use super::ui;
 
     if self.by.is_empty() && self.order.is_empty() && self.selector.is_none() {
       let document = parse_file(&self.file);
 
-      eprintln!("{RED}Error:{RESET} specify a selector, --by, or --order");
+      eprintln!("{} specify a selector, --by, or --order", ui::failure("Error:"));
       eprintln!();
-      eprintln!("  {BOLD}Examples:{RESET}");
+      eprintln!("  {}", ui::strong("Examples:"));
       eprintln!("    yerba sort \"{}\" \"tags\"", self.file);
       eprintln!("    yerba sort \"{}\" --by \".title\" --order asc", self.file);
       eprintln!();
@@ -80,10 +81,8 @@ impl Args {
   }
 
   fn show_values(self) {
-    use super::color::*;
-
     if self.by.len() != 1 {
-      eprintln!("{RED}Error:{RESET} --order is required when using --by");
+      eprintln!("{} --order is required when using --by", ui::failure("Error:"));
       process::exit(1);
     }
 
@@ -94,14 +93,14 @@ impl Args {
     let (labels, context_values, selector_display) = self.resolve_labels(&document, by, selector, &items_selector);
 
     let context_hint = if self.context.is_empty() {
-      format!("\n\n  {DIM}Add --context \".field\" to show additional fields alongside values{RESET}")
+      format!("\n\n  {}", ui::subtle("Add --context \".field\" to show additional fields alongside values"))
     } else {
       String::new()
     };
 
-    eprintln!("{RED}Error:{RESET} --order is required when using --by");
+    eprintln!("{} --order is required when using --by", ui::failure("Error:"));
     eprintln!();
-    eprintln!("  {BOLD}Current values (by {by}):{RESET}");
+    eprintln!("  {}", ui::strong(format!("Current values (by {}):", by)));
 
     for (index, label) in labels.iter().enumerate() {
       let context = context_values.get(index).map(|c| c.as_slice()).unwrap_or(&[]);
@@ -113,22 +112,20 @@ impl Args {
 
     eprintln!("{context_hint}");
     eprintln!();
-    eprintln!("  {BOLD}To sort alphabetically:{RESET}");
+    eprintln!("  {}", ui::strong("To sort alphabetically:"));
     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!("  {}", ui::strong("To reorder explicitly:"));
     eprintln!("    yerba sort \"{}\"{selector_display} --by \"{by}\" --order \"{csv}\"", self.file);
     eprintln!();
-    eprintln!("  {BOLD}To move individual items:{RESET}");
+    eprintln!("  {}", ui::strong("To move individual items:"));
     eprintln!("    yerba move \"{}\"{selector_display} <item> --before/--after <target>", self.file);
 
     process::exit(1);
   }
 
   fn run_sort(self) {
-    use super::color::*;
-
     let selector = self.selector.as_deref().unwrap_or("");
 
     let sort_fields: Vec<yerba::SortField> = if self.by.is_empty() {
@@ -145,7 +142,7 @@ impl Args {
             Some("desc" | "descending") => yerba::SortField::desc(field),
             Some("asc" | "ascending") | None => yerba::SortField::asc(field),
             Some(other) => {
-              eprintln!("{RED}Error:{RESET} invalid sort direction \"{other}\". Use \"asc\" or \"desc\"");
+              eprintln!("{} invalid sort direction \"{other}\". Use \"asc\" or \"desc\"", ui::failure("Error:"));
               process::exit(1);
             }
           }
@@ -161,7 +158,7 @@ impl Args {
 
         match document.get_value(&first_item_selector) {
           Some(first) if first.is_mapping() => {
-            eprintln!("{RED}Error:{RESET} --by is required to sort a sequence of maps");
+            eprintln!("{} --by is required to sort a sequence of maps", ui::failure("Error:"));
             eprintln!();
 
             let selectors = document.selectors();
@@ -175,7 +172,7 @@ impl Args {
               .collect();
 
             if !fields.is_empty() {
-              eprintln!("  {BOLD}Available fields:{RESET}");
+              eprintln!("  {}", ui::strong("Available fields:"));
 
               for field in &fields {
                 let short = field.rsplit_once('.').map(|(_, f)| f).unwrap_or(field);
@@ -187,9 +184,9 @@ impl Args {
           }
 
           None if selector.is_empty() => {
-            eprintln!("{RED}Error:{RESET} no sequence found at root level in {}", resolved_file);
+            eprintln!("{} no sequence found at root level in {}", ui::failure("Error:"), resolved_file);
             eprintln!();
-            eprintln!("  {DIM}Specify a selector for the sequence to sort:{RESET}");
+            eprintln!("  {}", ui::subtle("Specify a selector for the sequence to sort:"));
             eprintln!("    yerba sort \"{}\" \"<selector>\"", self.file);
             eprintln!();
 
@@ -209,16 +206,14 @@ impl Args {
   }
 
   fn run_reorder(self) {
-    use super::color::*;
-
     if self.by.len() != 1 {
-      eprintln!("{RED}Error:{RESET} explicit --order requires exactly one --by field");
+      eprintln!("{} explicit --order requires exactly one --by field", ui::failure("Error:"));
 
       process::exit(1);
     }
 
     if self.order.len() != 1 {
-      eprintln!("{RED}Error:{RESET} explicit --order must be a single comma-separated list");
+      eprintln!("{} explicit --order must be a single comma-separated list", ui::failure("Error:"));
 
       process::exit(1);
     }
@@ -236,17 +231,17 @@ impl Args {
     let duplicates: Vec<&String> = labels.iter().filter(|label| !seen.insert(label.as_str())).collect();
 
     if !duplicates.is_empty() {
-      eprintln!("{RED}Error:{RESET} --order requires unique values for {by}, but found duplicates");
+      eprintln!("{} --order requires unique values for {by}, but found duplicates", ui::failure("Error:"));
       eprintln!();
-      eprintln!("  {BOLD}Duplicate values:{RESET}");
+      eprintln!("  {}", ui::strong("Duplicate values:"));
 
       for label in &duplicates {
         eprintln!("    {label}");
       }
 
       eprintln!();
-      eprintln!("  {DIM}Use \"yerba sort\" with --by instead to sort by field, or");
-      eprintln!("  choose a --by field with unique values (e.g. \".id\"){RESET}");
+      eprintln!("  {}", ui::subtle("Use \"yerba sort\" with --by instead to sort by field, or"));
+      eprintln!("  {}", ui::subtle("choose a --by field with unique values (e.g. \".id\")"));
 
       process::exit(1);
     }
@@ -256,16 +251,19 @@ impl Args {
     if !values_with_commas.is_empty() {
       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!(
+        "{} some values for {by} contain commas, which conflicts with --order parsing",
+        ui::failure("Error:")
+      );
       eprintln!();
-      eprintln!("  {BOLD}Values with commas:{RESET}");
+      eprintln!("  {}", ui::strong("Values with commas:"));
 
       for label in &values_with_commas {
         eprintln!("    {label}");
       }
 
       eprintln!();
-      eprintln!("  {BOLD}Use yerba move to reorder individual items instead:{RESET}");
+      eprintln!("  {}", ui::strong("Use yerba move to reorder individual items instead:"));
       eprintln!("    yerba move \"{}\"{selector_display} <item> --before/--after <target>", self.file);
 
       process::exit(1);
@@ -277,28 +275,26 @@ impl Args {
     match document.reorder_items(container, by, &desired_order) {
       Ok(()) => output(&self.file, &document, self.dry_run),
       Err(error) => {
-        eprintln!("{RED}Error:{RESET} {}", error);
+        eprintln!("{} {}", ui::failure("Error:"), error);
         process::exit(1);
       }
     }
   }
 
   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);
 
     if items.is_empty() {
       if selector.is_empty() {
-        eprintln!("{RED}Error:{RESET} no sequence found at root level");
+        eprintln!("{} no sequence found at root level", ui::failure("Error:"));
         eprintln!();
-        eprintln!("  {DIM}If the file is a map, specify which sequence to sort:{RESET}");
+        eprintln!("  {}", ui::subtle("If the file is a map, specify which sequence to sort:"));
         eprintln!("    yerba sort \"{}\" \"<selector>\" --by \"{by}\" --order asc", self.file);
         eprintln!();
 
         super::show_similar_selectors(&self.file, document, "[]");
       } else {
-        eprintln!("{RED}Error:{RESET} no sequence found at selector: {selector}");
+        eprintln!("{} no sequence found at selector: {selector}", ui::failure("Error:"));
 
         super::show_similar_selectors(&self.file, document, selector);
       }
@@ -316,7 +312,7 @@ impl Args {
       };
 
       if !document.exists(&by_selector) {
-        eprintln!("{RED}Error:{RESET} field \"{by}\" not found in items");
+        eprintln!("{} field \"{by}\" not found in items", ui::failure("Error:"));
 
         super::show_similar_selectors(&self.file, document, &by_selector);
 
@@ -367,17 +363,15 @@ impl Args {
   }
 
   fn format_label_line(&self, index: usize, label: &str, context: &[String]) -> String {
-    use super::color::*;
-
     if context.is_empty() {
-      format!("{DIM}[{index}]{RESET} {label}")
+      format!("{} {}", ui::subtle(format!("[{}]", index)), label)
     } else {
       let context = context.iter().filter(|c| !c.is_empty()).cloned().collect::<Vec<_>>().join(", ");
 
       if context.is_empty() {
-        format!("{DIM}[{index}]{RESET} {label}")
+        format!("{} {}", ui::subtle(format!("[{}]", index)), label)
       } else {
-        format!("{DIM}[{index}]{RESET} {label}  {DIM}{context}{RESET}")
+        format!("{} {}  {}", ui::subtle(format!("[{}]", index)), label, ui::subtle(context))
       }
     }
   }

data/rust/src/commands/sort_keys.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::process;
 use std::sync::LazyLock;
 
@@ -41,8 +42,7 @@ impl Args {
       let document = parse_file(resolved_file);
 
       if let Err(error) = document.validate_sort_keys(&self.selector, &key_order) {
-        use super::color::*;
-        eprintln!("{RED}Error in {}{RESET}: {}", resolved_file, error);
+        eprintln!("{}: {}", ui::failure(format!("Error in {}", resolved_file)), error);
         has_errors = true;
       }
     }

data/rust/src/commands/ui.rs

@@ -0,0 +1,157 @@
+use std::io::IsTerminal;
+use std::sync::OnceLock;
+
+fn colored() -> bool {
+  static COLORED: OnceLock<bool> = OnceLock::new();
+
+  *COLORED.get_or_init(|| {
+    if std::env::var_os("NO_COLOR").is_some() {
+      return false;
+    }
+
+    if std::env::var_os("CLICOLOR_FORCE").is_some_and(|value| value != "0") {
+      return true;
+    }
+
+    std::io::stderr().is_terminal() || super::is_github_actions()
+  })
+}
+
+#[derive(Clone, Copy)]
+pub struct Color(&'static str);
+
+pub const GREEN: Color = Color("32");
+pub const YELLOW: Color = Color("33");
+pub const RED: Color = Color("31");
+pub const CYAN: Color = Color("36");
+
+pub struct Style {
+  color: Option<Color>,
+  bold: bool,
+  dim: bool,
+}
+
+impl Style {
+  pub const fn plain() -> Self {
+    Style {
+      color: None,
+      bold: false,
+      dim: false,
+    }
+  }
+
+  pub const fn fg(color: Color) -> Self {
+    Style {
+      color: Some(color),
+      bold: false,
+      dim: false,
+    }
+  }
+
+  pub const fn bold(mut self) -> Self {
+    self.bold = true;
+    self
+  }
+
+  pub const fn dim(mut self) -> Self {
+    self.dim = true;
+    self
+  }
+
+  pub fn paint(&self, text: impl std::fmt::Display) -> String {
+    if !colored() {
+      return text.to_string();
+    }
+
+    let mut codes: Vec<&str> = Vec::new();
+
+    if self.bold {
+      codes.push("1");
+    }
+
+    if self.dim {
+      codes.push("2");
+    }
+
+    if let Some(color) = &self.color {
+      codes.push(color.0);
+    }
+
+    if codes.is_empty() {
+      return text.to_string();
+    }
+
+    format!("\x1b[{}m{}\x1b[0m", codes.join(";"), text)
+  }
+}
+
+pub fn success(text: impl std::fmt::Display) -> String {
+  Style::fg(GREEN).bold().paint(text)
+}
+
+pub fn pending(text: impl std::fmt::Display) -> String {
+  Style::fg(YELLOW).bold().paint(text)
+}
+
+pub fn failure(text: impl std::fmt::Display) -> String {
+  Style::fg(RED).bold().paint(text)
+}
+
+pub fn muted(text: impl std::fmt::Display) -> String {
+  Style::fg(CYAN).paint(text)
+}
+
+pub fn subtle(text: impl std::fmt::Display) -> String {
+  Style::plain().dim().paint(text)
+}
+
+pub fn strong(text: impl std::fmt::Display) -> String {
+  Style::plain().bold().paint(text)
+}
+
+pub fn banner() -> String {
+  format!("🧉 {} {}", Style::fg(GREEN).bold().paint("yerba"), subtle(format!("v{}", yerba::version())))
+}
+
+pub const INDENT: &str = "   ";
+pub const STATUS_INDENT: &str = "  ";
+
+pub mod glyph {
+  pub const OK: &str = "✓";
+  pub const PENDING: &str = "~";
+  pub const FAIL: &str = "✗";
+}
+
+pub mod raw {
+  fn sequence(code: &'static str) -> &'static str {
+    if super::colored() {
+      code
+    } else {
+      ""
+    }
+  }
+
+  pub fn green() -> &'static str {
+    sequence("\x1b[32m")
+  }
+
+  pub fn yellow() -> &'static str {
+    sequence("\x1b[33m")
+  }
+
+  pub fn bold() -> &'static str {
+    sequence("\x1b[1m")
+  }
+
+  pub fn dim() -> &'static str {
+    sequence("\x1b[2m")
+  }
+
+  pub fn italic() -> &'static str {
+    sequence("\x1b[3m")
+  }
+
+  pub fn reset() -> &'static str {
+    sequence("\x1b[0m")
+  }
+}

data/rust/src/commands/unique.rs

@@ -37,7 +37,7 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    use super::color::*;
+    use super::ui;
 
     let selector = self.selector.as_deref().unwrap_or("");
     let by = self.by.as_deref().unwrap_or(".");
@@ -50,20 +50,20 @@ impl Args {
           let noun = if duplicates.len() == 1 { "duplicate" } else { "duplicates" };
 
           if duplicates.is_empty() {
-            eprintln!("{GREEN}No duplicates found{RESET} in {}", resolved_file);
+            eprintln!("{} in {}", ui::success("No duplicates found"), resolved_file);
           } else if self.remove {
-            eprintln!("{YELLOW}Removed {} {noun}{RESET} from {}", duplicates.len(), resolved_file);
+            eprintln!("{} from {}", ui::pending(format!("Removed {} {noun}", duplicates.len())), resolved_file);
 
             for duplicate in &duplicates {
-              eprintln!("  {DIM}line {}: {} == {}{RESET}", duplicate.line, by, duplicate.value);
+              eprintln!("  {}", ui::subtle(format!("line {}: {} == {}", duplicate.line, by, duplicate.value)));
             }
 
             output(&resolved_file, &document, self.dry_run);
           } else {
-            eprintln!("{RED}Found {} {noun}{RESET} in {}", duplicates.len(), resolved_file);
+            eprintln!("{} in {}", ui::failure(format!("Found {} {noun}", duplicates.len())), resolved_file);
 
             for duplicate in &duplicates {
-              eprintln!("  {DIM}line {}: {} == {}{RESET}", duplicate.line, by, duplicate.value);
+              eprintln!("  {}", ui::subtle(format!("line {}: {} == {}", duplicate.line, by, duplicate.value)));
             }
 
             process::exit(1);
@@ -71,7 +71,7 @@ impl Args {
         }
 
         Err(error) => {
-          eprintln!("{RED}Error:{RESET} {}", error);
+          eprintln!("{} {}", ui::failure("Error:"), error);
           process::exit(1);
         }
       }

data/rust/src/commands/version.rs

@@ -1,8 +1,18 @@
-use super::color::*;
+use super::ui;
 
 pub fn run() {
-  println!("🧉 {BOLD}yerba{RESET} {DIM}v{}{RESET}", yerba::version());
+  println!("{}", ui::banner());
   println!(
-    "   {BOLD}Y{RESET}{DIM}AML{RESET} {BOLD}E{RESET}{DIM}diting and{RESET} {BOLD}R{RESET}{DIM}efactoring with{RESET} {BOLD}B{RESET}{DIM}etter{RESET} {BOLD}A{RESET}{DIM}ccuracy{RESET}"
+    "   {}{} {}{} {}{} {}{} {}{}",
+    ui::strong("Y"),
+    ui::subtle("AML"),
+    ui::strong("E"),
+    ui::subtle("diting and"),
+    ui::strong("R"),
+    ui::subtle("efactoring with"),
+    ui::strong("B"),
+    ui::subtle("etter"),
+    ui::strong("A"),
+    ui::subtle("ccuracy")
   );
 }

data/rust/src/document/condition.rs

@@ -1,29 +1,83 @@
 use super::*;
 
+const CONDITION_OPERATORS: &str = "expected `<selector> <operator> <value>`, where operator is one of ==, !=, contains, not_contains";
+
+pub fn validate_condition(condition: &str) -> Result<(), YerbaError> {
+  let trimmed = condition.trim();
+
+  if trimmed.is_empty() {
+    return Err(YerbaError::InvalidCondition(condition.to_string(), "condition is empty".to_string()));
+  }
+
+  let Some((left, _operator, _right)) = parse_condition(trimmed) else {
+    return Err(YerbaError::InvalidCondition(condition.to_string(), CONDITION_OPERATORS.to_string()));
+  };
+
+  if crate::selector::Selector::parse(&left).is_empty() {
+    return Err(YerbaError::InvalidCondition(
+      condition.to_string(),
+      "condition is missing a selector on the left of the operator".to_string(),
+    ));
+  }
+
+  Ok(())
+}
+
+pub fn validate_item_condition(condition: &str) -> Result<(), YerbaError> {
+  validate_condition(condition)?;
+
+  let trimmed = condition.trim();
+
+  let Some((left, _operator, _right)) = parse_condition(trimmed) else {
+    return Ok(());
+  };
+
+  if !crate::selector::Selector::parse(&left).is_relative() {
+    return Err(YerbaError::InvalidCondition(
+      condition.to_string(),
+      format!(
+        "selector \"{}\" is absolute, but this condition is tested against each item, so it must be relative and start with `.` — did you mean \".{}\"?",
+        left.trim(),
+        left.trim()
+      ),
+    ));
+  }
+
+  Ok(())
+}
+
 impl Document {
-  pub fn filter(&self, dot_path: &str, condition: &str) -> Vec<yaml_serde::Value> {
-    self
-      .navigate_all_compact(dot_path)
-      .iter()
-      .filter(|node| self.evaluate_condition_on_node(node, condition))
-      .map(node_to_yaml_value)
-      .collect()
+  pub fn filter(&self, dot_path: &str, condition: &str) -> Result<Vec<yaml_serde::Value>, YerbaError> {
+    validate_item_condition(condition)?;
+
+    Ok(
+      self
+        .navigate_all_compact(dot_path)
+        .iter()
+        .filter(|node| self.evaluate_condition_on_node(node, condition))
+        .map(node_to_yaml_value)
+        .collect(),
+    )
   }
 
-  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Vec<(yaml_serde::Value, String, usize)> {
+  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Result<Vec<(yaml_serde::Value, String, usize)>, YerbaError> {
+    validate_item_condition(condition)?;
+
     let source = self.source_text();
 
-    self
-      .navigate_all_compact(dot_path)
-      .iter()
-      .filter(|node| self.evaluate_condition_on_node(node, condition))
-      .map(|node| {
-        let offset: usize = node.text_range().start().into();
-        let line = line_at(&source, offset);
-
-        (node_to_yaml_value(node), super::get::node_selector(node), line)
-      })
-      .collect()
+    Ok(
+      self
+        .navigate_all_compact(dot_path)
+        .iter()
+        .filter(|node| self.evaluate_condition_on_node(node, condition))
+        .map(|node| {
+          let offset: usize = node.text_range().start().into();
+          let line = line_at(&source, offset);
+
+          (node_to_yaml_value(node), super::get::node_selector(node), line)
+        })
+        .collect(),
+    )
   }
 
   pub(super) fn evaluate_condition_on_node(&self, node: &SyntaxNode, condition: &str) -> bool {
@@ -84,31 +138,32 @@ impl Document {
     }
   }
 
-  pub fn evaluate_condition(&self, parent_path: &str, condition: &str) -> bool {
+  pub fn evaluate_condition(&self, parent_path: &str, condition: &str) -> Result<bool, YerbaError> {
+    if parent_path.is_empty() {
+      validate_condition(condition)?;
+    } else {
+      validate_item_condition(condition)?;
+    }
+
     let condition = condition.trim();
 
     let (left, operator, right) = match parse_condition(condition) {
       Some(parts) => parts,
-      None => return false,
+      None => return Ok(false),
     };
 
     let path = crate::selector::Selector::parse(&left);
+    let path_string = path.to_selector_string();
 
-    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)
-      }
+    let full_path = if parent_path.is_empty() {
+      path_string
     } else {
-      path.to_selector_string()
+      format!("{}.{}", parent_path, path_string)
     };
 
     let has_brackets = crate::selector::Selector::parse(&full_path).has_brackets();
 
-    match operator {
+    let result = match operator {
       "==" => {
         if has_brackets {
           self.get_all(&full_path).iter().any(|value| value == &right)
@@ -150,6 +205,8 @@ impl Document {
         }
       }
       _ => false,
-    }
+    };
+
+    Ok(result)
   }
 }

data/rust/src/document/delete.rs

@@ -31,6 +31,7 @@ impl Document {
 
   pub fn delete(&mut self, dot_path: &str) -> Result<(), YerbaError> {
     Self::validate_path(dot_path)?;
+    self.refuse_flow_target(dot_path)?;
 
     let selector = crate::selector::Selector::parse(dot_path);
     let segments = selector.segments();
@@ -88,13 +89,17 @@ impl Document {
       }
 
       crate::selector::SelectorSegment::Index(index) => self.remove_at(&parent_path, *index),
-      crate::selector::SelectorSegment::AllItems => Err(YerbaError::SelectorNotFound(dot_path.to_string())),
+      crate::selector::SelectorSegment::AllItems | crate::selector::SelectorSegment::AllKeys => Err(YerbaError::SelectorNotFound(dot_path.to_string())),
     }
   }
 
   pub fn remove(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
     let current_node = self.navigate(dot_path)?;
 
+    if find_flow_sequence(&current_node).is_some() {
+      return Err(YerbaError::FlowCollectionNotWritable(dot_path.to_string()));
+    }
+
     let sequence = find_block_sequence(&current_node).ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
 
     let target_entry = sequence