yerba 0.2.2-arm-linux-gnu → 0.4.0-arm-linux-gnu

data/rust/src/commands/sort.rs

@@ -1,3 +1,4 @@
+use std::process;
 use std::sync::LazyLock;
 
 use indoc::indoc;
@@ -8,17 +9,17 @@ use super::{output, parse_file, resolve_files};
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
     yerba sort config.yml "tags"
-    yerba sort videos.yml --by "title"
-    yerba sort videos.yml --by "date:desc,title"
-    yerba sort videos.yml "[].speakers"
-    yerba sort videos.yml "[].speakers" --by "name"
-    yerba sort videos.yml --by "kind,date:desc,title" --dry-run
+    yerba sort videos.yml --by ".title"
+    yerba sort videos.yml --by ".date" --order desc --by ".title"
+    yerba sort videos.yml "[].speakers" --by ".name"
+    yerba sort videos.yml "[]" --by ".id" --order "talk-3,talk-1,talk-2"
+    yerba sort speakers.yml "[]" --by ".name" --order "Charlie,Alice,Bob"
   "#})
 });
 
 #[derive(clap::Args)]
 #[command(
-  about = "Sort items in a sequence by field(s)",
+  about = "Sort or reorder items in a sequence",
   arg_required_else_help = true,
   after_help = EXAMPLES.as_str()
 )]
@@ -26,9 +27,15 @@ pub struct Args {
   file: String,
   /// Selector (optional — omit for root-level sequence)
   selector: Option<String>,
-  /// Comma-separated sort fields, optionally with :desc (e.g. "date:desc,title")
-  #[arg(long)]
-  by: Option<String>,
+  /// Field to sort or match by (can be repeated for tie-breakers)
+  #[arg(long, action = clap::ArgAction::Append)]
+  by: Vec<String>,
+  /// Sort direction (asc/desc) or explicit order (comma-separated values, must list all items)
+  #[arg(long, action = clap::ArgAction::Append)]
+  order: Vec<String>,
+  /// Additional fields to display alongside values (e.g. --context ".title")
+  #[arg(long, action = clap::ArgAction::Append)]
+  context: Vec<String>,
   /// Case-sensitive sort (default: case-insensitive)
   #[arg(long)]
   case_sensitive: bool,
@@ -36,17 +43,342 @@ pub struct Args {
   dry_run: bool,
 }
 
+fn is_direction(value: &str) -> bool {
+  matches!(value, "asc" | "desc" | "ascending" | "descending")
+}
+
+fn is_explicit_reorder(orders: &[String]) -> bool {
+  orders.iter().any(|o| !is_direction(o))
+}
+
 impl Args {
   pub fn run(self) {
+    use super::color::*;
+
+    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!();
+      eprintln!("  {BOLD}Examples:{RESET}");
+      eprintln!("    yerba sort \"{}\" \"tags\"", self.file);
+      eprintln!("    yerba sort \"{}\" --by \".title\" --order asc", self.file);
+      eprintln!();
+
+      super::show_similar_selectors(&self.file, &document, "[]");
+
+      process::exit(1);
+    }
+
+    if !self.by.is_empty() && self.order.is_empty() {
+      self.show_values();
+    } else if is_explicit_reorder(&self.order) {
+      self.run_reorder();
+    } else {
+      self.run_sort();
+    }
+  }
+
+  fn show_values(self) {
+    use super::color::*;
+
+    if self.by.len() != 1 {
+      eprintln!("{RED}Error:{RESET} --order is required when using --by");
+      process::exit(1);
+    }
+
+    let by = &self.by[0];
     let selector = self.selector.as_deref().unwrap_or("");
-    let sort_fields = self.by.as_deref().map(yerba::SortField::parse_list).unwrap_or_default();
+    let items_selector = if selector.is_empty() { "[]".to_string() } else { format!("{}[]", selector) };
+    let document = parse_file(&self.file);
+    let (labels, context_values, selector_display) = self.resolve_labels(&document, by, selector, &items_selector);
+
+    let context_hint = if self.context.is_empty() {
+      format!("\n\n  {DIM}Add --context \".field\" to show additional fields alongside values{RESET}")
+    } else {
+      String::new()
+    };
+
+    eprintln!("{RED}Error:{RESET} --order is required when using --by");
+    eprintln!();
+    eprintln!("  {BOLD}Current values (by {by}):{RESET}");
+
+    for (index, label) in labels.iter().enumerate() {
+      let context = context_values.get(index).map(|c| c.as_slice()).unwrap_or(&[]);
+
+      eprintln!("    {}", self.format_label_line(index, label, context));
+    }
+
+    let csv: String = labels.join(",");
+
+    eprintln!("{context_hint}");
+    eprintln!();
+    eprintln!("  {BOLD}To sort alphabetically:{RESET}");
+    eprintln!("    yerba sort \"{}\"{selector_display} --by \"{by}\" --order asc", self.file);
+    eprintln!("    yerba sort \"{}\"{selector_display} --by \"{by}\" --order desc", self.file);
+    eprintln!();
+    eprintln!("  {BOLD}To reorder explicitly:{RESET}");
+    eprintln!("    yerba sort \"{}\"{selector_display} --by \"{by}\" --order \"{csv}\"", self.file);
+    eprintln!();
+    eprintln!("  {BOLD}To move individual items:{RESET}");
+    eprintln!("    yerba move \"{}\"{selector_display} <item> --before/--after <target>", self.file);
+
+    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() {
+      Vec::new()
+    } else {
+      self
+        .by
+        .iter()
+        .enumerate()
+        .map(|(index, field)| {
+          let direction = self.order.get(index).map(|s| s.as_str());
+
+          match direction {
+            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\"");
+              process::exit(1);
+            }
+          }
+        })
+        .collect()
+    };
 
     for resolved_file in resolve_files(&self.file) {
       let mut document = parse_file(&resolved_file);
 
+      if sort_fields.is_empty() {
+        let first_item_selector = if selector.is_empty() { "[0]".to_string() } else { format!("{}[0]", selector) };
+
+        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!();
+
+            let selectors = document.selectors();
+            let prefix = if selector.is_empty() { "[]." } else { "" };
+            let fields: Vec<&String> = selectors
+              .iter()
+              .filter(|s| {
+                let check = if prefix.is_empty() { format!("{}[].", selector) } else { prefix.to_string() };
+                s.starts_with(&check) && !s[check.len()..].contains('.') && !s[check.len()..].contains('[')
+              })
+              .collect();
+
+            if !fields.is_empty() {
+              eprintln!("  {BOLD}Available fields:{RESET}");
+
+              for field in &fields {
+                let short = field.rsplit_once('.').map(|(_, f)| f).unwrap_or(field);
+                eprintln!("    .{short}");
+              }
+            }
+
+            process::exit(1);
+          }
+
+          None if selector.is_empty() => {
+            eprintln!("{RED}Error:{RESET} no sequence found at root level in {}", resolved_file);
+            eprintln!();
+            eprintln!("  {DIM}Specify a selector for the sequence to sort:{RESET}");
+            eprintln!("    yerba sort \"{}\" \"<selector>\"", self.file);
+            eprintln!();
+
+            super::show_similar_selectors(&resolved_file, &document, "[]");
+
+            process::exit(1);
+          }
+
+          _ => {}
+        }
+      }
+
       if document.sort_items(selector, &sort_fields, self.case_sensitive).is_ok() {
         output(&resolved_file, &document, self.dry_run);
       }
     }
   }
+
+  fn run_reorder(self) {
+    use super::color::*;
+
+    if self.by.len() != 1 {
+      eprintln!("{RED}Error:{RESET} explicit --order requires exactly one --by field");
+
+      process::exit(1);
+    }
+
+    if self.order.len() != 1 {
+      eprintln!("{RED}Error:{RESET} explicit --order must be a single comma-separated list");
+
+      process::exit(1);
+    }
+
+    let by = &self.by[0];
+    let order = &self.order[0];
+    let selector = self.selector.as_deref().unwrap_or("");
+
+    let items_selector = if selector.is_empty() { "[]".to_string() } else { format!("{}[]", selector) };
+
+    let mut document = parse_file(&self.file);
+    let mut seen = std::collections::HashSet::new();
+
+    let (labels, _, _) = self.resolve_labels(&document, by, selector, &items_selector);
+    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!();
+      eprintln!("  {BOLD}Duplicate values:{RESET}");
+
+      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}");
+
+      process::exit(1);
+    }
+
+    let values_with_commas: Vec<&String> = labels.iter().filter(|l| l.contains(',')).collect();
+
+    if !values_with_commas.is_empty() {
+      let selector_display = if selector.is_empty() { String::new() } else { format!(" \"{selector}\"") };
+
+      eprintln!("{RED}Error:{RESET} some values for {by} contain commas, which conflicts with --order parsing");
+      eprintln!();
+      eprintln!("  {BOLD}Values with commas:{RESET}");
+
+      for label in &values_with_commas {
+        eprintln!("    {label}");
+      }
+
+      eprintln!();
+      eprintln!("  {BOLD}Use yerba move to reorder individual items instead:{RESET}");
+      eprintln!("    yerba move \"{}\"{selector_display} <item> --before/--after <target>", self.file);
+
+      process::exit(1);
+    }
+
+    let desired_order: Vec<&str> = order.split(',').map(|s| s.trim()).collect();
+    let container = if selector.is_empty() { "" } else { selector };
+
+    match document.reorder_items(container, by, &desired_order) {
+      Ok(()) => output(&self.file, &document, self.dry_run),
+      Err(error) => {
+        eprintln!("{RED}Error:{RESET} {}", error);
+        process::exit(1);
+      }
+    }
+  }
+
+  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!();
+        eprintln!("  {DIM}If the file is a map, specify which sequence to sort:{RESET}");
+        eprintln!("    yerba sort \"{}\" \"<selector>\" --by \"{by}\" --order asc", self.file);
+        eprintln!();
+
+        super::show_similar_selectors(&self.file, document, "[]");
+      } else {
+        eprintln!("{RED}Error:{RESET} no sequence found at selector: {selector}");
+
+        super::show_similar_selectors(&self.file, document, selector);
+      }
+
+      process::exit(1);
+    }
+
+    let by_is_scalar = by == ".";
+
+    if !by_is_scalar {
+      let by_selector = if selector.is_empty() {
+        format!("[].{}", by.strip_prefix('.').unwrap_or(by))
+      } else {
+        format!("{}[].{}", selector, by.strip_prefix('.').unwrap_or(by))
+      };
+
+      if !document.exists(&by_selector) {
+        eprintln!("{RED}Error:{RESET} field \"{by}\" not found in items");
+
+        super::show_similar_selectors(&self.file, document, &by_selector);
+
+        process::exit(1);
+      }
+    }
+
+    let labels: Vec<String> = items
+      .iter()
+      .map(|item| {
+        if by_is_scalar {
+          match item {
+            serde_yaml::Value::String(string) => string.clone(),
+            _ => serde_json::to_string(&yerba::json::yaml_to_json(item)).unwrap_or_default(),
+          }
+        } else {
+          let field = by.strip_prefix('.').unwrap_or(by);
+
+          yerba::json::resolve_select_field(item, field).as_str().unwrap_or("").to_string()
+        }
+      })
+      .collect();
+
+    let context_values: Vec<Vec<String>> = items
+      .iter()
+      .map(|item| {
+        self
+          .context
+          .iter()
+          .map(|context| {
+            let field = context.strip_prefix('.').unwrap_or(context);
+
+            let value = yerba::json::resolve_select_field(item, field);
+
+            match &value {
+              serde_json::Value::String(string) => string.clone(),
+              serde_json::Value::Null => String::new(),
+              _ => serde_json::to_string(&value).unwrap_or_default(),
+            }
+          })
+          .collect()
+      })
+      .collect();
+
+    let selector_display = if selector.is_empty() { String::new() } else { format!(" \"{selector}\"") };
+
+    (labels, context_values, selector_display)
+  }
+
+  fn format_label_line(&self, index: usize, label: &str, context: &[String]) -> String {
+    use super::color::*;
+
+    if context.is_empty() {
+      format!("{DIM}[{index}]{RESET} {label}")
+    } else {
+      let context = context.iter().filter(|c| !c.is_empty()).cloned().collect::<Vec<_>>().join(", ");
+
+      if context.is_empty() {
+        format!("{DIM}[{index}]{RESET} {label}")
+      } else {
+        format!("{DIM}[{index}]{RESET} {label}  {DIM}{context}{RESET}")
+      }
+    }
+  }
 }

data/rust/src/didyoumean.rs

@@ -0,0 +1,53 @@
+pub fn didyoumean(input: &str, list: &[String]) -> Option<String> {
+  if list.is_empty() {
+    return None;
+  }
+
+  let input_lower = input.to_lowercase();
+
+  let mut scored: Vec<(String, usize)> = list
+    .iter()
+    .map(|item| (item.clone(), levenshtein(&input_lower, &item.to_lowercase())))
+    .collect();
+
+  scored.sort_by(|(a_item, a_distance), (b_item, b_distance)| a_distance.cmp(b_distance).then_with(|| a_item.cmp(b_item)));
+
+  scored.into_iter().next().map(|(item, _)| item)
+}
+
+pub fn didyoumean_ranked(input: &str, list: &[String], threshold: usize) -> Vec<String> {
+  if list.is_empty() {
+    return Vec::new();
+  }
+
+  let input_lower = input.to_lowercase();
+
+  let mut scored: Vec<(String, usize)> = list
+    .iter()
+    .map(|item| (item.clone(), levenshtein(&input_lower, &item.to_lowercase())))
+    .filter(|(_, distance)| *distance <= threshold)
+    .collect();
+
+  scored.sort_by(|(a_item, a_distance), (b_item, b_distance)| a_distance.cmp(b_distance).then_with(|| a_item.cmp(b_item)));
+
+  scored.into_iter().map(|(item, _)| item).collect()
+}
+
+fn levenshtein(a: &str, b: &str) -> usize {
+  let b_length = b.len();
+  let mut previous: Vec<usize> = (0..=b_length).collect();
+  let mut current = vec![0; b_length + 1];
+
+  for (i, a_character) in a.chars().enumerate() {
+    current[0] = i + 1;
+
+    for (j, b_character) in b.chars().enumerate() {
+      let cost = if a_character == b_character { 0 } else { 1 };
+      current[j + 1] = (previous[j] + cost).min(previous[j + 1] + 1).min(current[j] + 1);
+    }
+
+    std::mem::swap(&mut previous, &mut current);
+  }
+
+  previous[b_length]
+}

data/rust/src/document/condition.rs

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

data/rust/src/document/delete.rs

@@ -0,0 +1,91 @@
+use super::*;
+
+impl Document {
+  pub fn rename(&mut self, source_path: &str, destination_path: &str) -> Result<(), YerbaError> {
+    Self::validate_path(source_path)?;
+    Self::validate_path(destination_path)?;
+
+    let source_parent = source_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+    let destination_parent = destination_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+    let destination_key = destination_path.rsplit_once('.').map(|(_, key)| key).unwrap_or(destination_path);
+
+    if source_parent == destination_parent {
+      let (parent_path, source_key) = source_path.rsplit_once('.').unwrap_or(("", source_path));
+      let parent_node = self.navigate(parent_path)?;
+
+      let map = parent_node
+        .descendants()
+        .find_map(BlockMap::cast)
+        .ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
+
+      let entry = find_entry_by_key(&map, source_key).ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
+      let key_node = entry.key().ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
+      let key_token = find_scalar_token(key_node.syntax()).ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
+      let new_text = format_scalar_value(destination_key, key_token.kind());
+
+      self.replace_token(&key_token, &new_text)
+    } else {
+      let value = self.get(source_path).ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
+
+      self.delete(source_path)?;
+      self.insert_into(destination_path, &value, InsertPosition::Last)
+    }
+  }
+
+  pub fn delete(&mut self, dot_path: &str) -> Result<(), YerbaError> {
+    Self::validate_path(dot_path)?;
+
+    let (parent_path, last_key) = dot_path.rsplit_once('.').unwrap_or(("", dot_path));
+    let parent_node = self.navigate(parent_path)?;
+
+    let map = parent_node
+      .descendants()
+      .find_map(BlockMap::cast)
+      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+    let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+    self.remove_node(entry.syntax())
+  }
+
+  pub fn remove(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
+    let current_node = self.navigate(dot_path)?;
+
+    let sequence = current_node
+      .descendants()
+      .find_map(BlockSeq::cast)
+      .ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
+
+    let target_entry = sequence
+      .entries()
+      .find(|entry| {
+        entry
+          .flow()
+          .and_then(|flow| extract_scalar_text(flow.syntax()))
+          .map(|text| text == value)
+          .unwrap_or(false)
+      })
+      .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", dot_path, value)))?;
+
+    self.remove_node(target_entry.syntax())
+  }
+
+  pub fn remove_at(&mut self, dot_path: &str, index: usize) -> Result<(), YerbaError> {
+    Self::validate_path(dot_path)?;
+
+    let current_node = self.navigate(dot_path)?;
+
+    let sequence = current_node
+      .descendants()
+      .find_map(BlockSeq::cast)
+      .ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
+
+    let entries: Vec<_> = sequence.entries().collect();
+
+    if index >= entries.len() {
+      return Err(YerbaError::IndexOutOfBounds(index, entries.len()));
+    }
+
+    self.remove_node(entries[index].syntax())
+  }
+}