yerba 0.3.0-arm-linux-gnu → 0.4.0-arm-linux-gnu

data/rust/src/commands/sort.rs

@@ -89,13 +89,7 @@ impl Args {
 
     let by = &self.by[0];
     let selector = self.selector.as_deref().unwrap_or("");
-
-    let items_selector = if selector.is_empty() {
-      "[]".to_string()
-    } else {
-      format!("{}[]", selector)
-    };
-
+    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);
 
@@ -111,6 +105,7 @@ impl Args {
 
     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));
     }
 
@@ -119,26 +114,14 @@ impl Args {
     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!("    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!("    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
-    );
+    eprintln!("    yerba move \"{}\"{selector_display} <item> --before/--after <target>", self.file);
 
     process::exit(1);
   }
@@ -174,11 +157,7 @@ impl Args {
       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)
-        };
+        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() => {
@@ -190,11 +169,7 @@ impl Args {
             let fields: Vec<&String> = selectors
               .iter()
               .filter(|s| {
-                let check = if prefix.is_empty() {
-                  format!("{}[].", selector)
-                } else {
-                  prefix.to_string()
-                };
+                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();
@@ -212,10 +187,7 @@ impl Args {
           }
 
           None if selector.is_empty() => {
-            eprintln!(
-              "{RED}Error:{RESET} no sequence found at root level in {}",
-              resolved_file
-            );
+            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);
@@ -255,11 +227,7 @@ impl Args {
     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 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();
@@ -286,11 +254,7 @@ impl Args {
     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}\"")
-      };
+      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!();
@@ -302,108 +266,24 @@ impl Args {
 
       eprintln!();
       eprintln!("  {BOLD}Use yerba move to reorder individual items instead:{RESET}");
-      eprintln!(
-        "    yerba move \"{}\"{selector_display} <item> --before/--after <target>",
-        self.file
-      );
+      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 mut used = vec![false; labels.len()];
-    let mut moves: Vec<usize> = Vec::new();
-
-    for desired in &desired_order {
-      let found = labels
-        .iter()
-        .enumerate()
-        .find(|(index, label)| label.as_str() == *desired && !used[*index]);
-
-      if let Some((index, _)) = found {
-        moves.push(index);
-        used[index] = true;
-      } else {
-        eprintln!("{RED}Error:{RESET} no item found with {by} == \"{desired}\"");
-        eprintln!();
-        eprintln!("  {BOLD}Available values:{RESET}");
-
-        for (index, label) in labels.iter().enumerate() {
-          eprintln!("    {DIM}{index}:{RESET} {label}");
-        }
-
-        process::exit(1);
-      }
-    }
-
-    let missing: Vec<&String> = labels
-      .iter()
-      .enumerate()
-      .filter(|(index, _)| !used[*index])
-      .map(|(_, label)| label)
-      .collect();
-
-    if !missing.is_empty() {
-      eprintln!(
-        "{RED}Error:{RESET} --order must specify all {} items, but {} are missing",
-        labels.len(),
-        missing.len()
-      );
-      eprintln!();
-      eprintln!("  {BOLD}Missing values:{RESET}");
-
-      for label in &missing {
-        eprintln!("    {label}");
-      }
-
-      eprintln!();
-      eprintln!("  {BOLD}All values (by {by}):{RESET}");
-
-      for label in &labels {
-        eprintln!("    {label}");
-      }
-
-      eprintln!();
-      eprintln!("  {BOLD}To move individual items, use:{RESET}");
-      eprintln!("    yerba move <file> <selector> <item> --before/--after <target>");
-
-      process::exit(1);
-    }
-
     let container = if selector.is_empty() { "" } else { selector };
 
-    for target in 0..moves.len() {
-      let source = moves[target];
-
-      if source != target {
-        let result = document.move_item(container, source, target);
-
-        if let Err(error) = result {
-          eprintln!("{RED}Error:{RESET} {}", error);
-          process::exit(1);
-        }
-
-        for item in moves.iter_mut().skip(target + 1) {
-          if *item >= target && *item < source {
-            *item += 1;
-          } else if *item == source {
-            *item = target;
-          }
-        }
+    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);
       }
     }
-
-    output(&self.file, &document, self.dry_run);
   }
 
-  fn resolve_labels(
-    &self,
-    document: &yerba::Document,
-    by: &str,
-    selector: &str,
-    items_selector: &str,
-  ) -> (Vec<String>, Vec<Vec<String>>, String) {
+  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);
@@ -413,10 +293,7 @@ impl Args {
         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!("    yerba sort \"{}\" \"<selector>\" --by \"{by}\" --order asc", self.file);
         eprintln!();
 
         super::show_similar_selectors(&self.file, document, "[]");
@@ -458,10 +335,7 @@ impl Args {
         } else {
           let field = by.strip_prefix('.').unwrap_or(by);
 
-          yerba::json::resolve_select_field(item, field)
-            .as_str()
-            .unwrap_or("")
-            .to_string()
+          yerba::json::resolve_select_field(item, field).as_str().unwrap_or("").to_string()
         }
       })
       .collect();
@@ -487,11 +361,7 @@ impl Args {
       })
       .collect();
 
-    let selector_display = if selector.is_empty() {
-      String::new()
-    } else {
-      format!(" \"{selector}\"")
-    };
+    let selector_display = if selector.is_empty() { String::new() } else { format!(" \"{selector}\"") };
 
     (labels, context_values, selector_display)
   }
@@ -502,12 +372,7 @@ impl Args {
     if context.is_empty() {
       format!("{DIM}[{index}]{RESET} {label}")
     } else {
-      let context = context
-        .iter()
-        .filter(|c| !c.is_empty())
-        .cloned()
-        .collect::<Vec<_>>()
-        .join(", ");
+      let context = context.iter().filter(|c| !c.is_empty()).cloned().collect::<Vec<_>>().join(", ");
 
       if context.is_empty() {
         format!("{DIM}[{index}]{RESET} {label}")

data/rust/src/didyoumean.rs

@@ -10,8 +10,7 @@ pub fn didyoumean(input: &str, list: &[String]) -> Option<String> {
     .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.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)
 }
@@ -29,8 +28,7 @@ pub fn didyoumean_ranked(input: &str, list: &[String], threshold: usize) -> Vec<
     .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.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()
 }

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())
+  }
+}