yerba 0.4.2 → 0.5.1

data/rust/src/document/get.rs

@@ -1,6 +1,37 @@
 use super::*;
 
 impl Document {
+  pub fn is_valid_selector(&self, dot_path: &str) -> bool {
+    if dot_path.is_empty() {
+      return true;
+    }
+
+    let selectors = self.selectors();
+
+    if selectors.contains(&dot_path.to_string()) {
+      return true;
+    }
+
+    let wildcard_version = dot_path.replace(|c: char| c.is_ascii_digit(), "").replace("[.", "[");
+
+    let mut normalized = String::new();
+    let mut chars = dot_path.chars().peekable();
+
+    while let Some(char) = chars.next() {
+      if char == '[' {
+        normalized.push('[');
+
+        while chars.peek().map(|char| char.is_ascii_digit()).unwrap_or(false) {
+          chars.next();
+        }
+      } else {
+        normalized.push(char);
+      }
+    }
+
+    selectors.contains(&normalized) || selectors.contains(&wildcard_version)
+  }
+
   pub fn get(&self, dot_path: &str) -> Option<String> {
     if dot_path.contains('[') {
       return self.get_all(dot_path).into_iter().next();
@@ -12,7 +43,7 @@ impl Document {
   }
 
   pub fn get_all(&self, dot_path: &str) -> Vec<String> {
-    self.navigate_all(dot_path).iter().filter_map(extract_scalar_text).collect()
+    self.navigate_all_compact(dot_path).iter().filter_map(extract_scalar_text).collect()
   }
 
   pub fn get_typed(&self, dot_path: &str) -> Option<ScalarValue> {
@@ -34,7 +65,7 @@ impl Document {
 
   pub fn get_all_typed(&self, dot_path: &str) -> Vec<ScalarValue> {
     self
-      .navigate_all(dot_path)
+      .navigate_all_compact(dot_path)
       .iter()
       .filter(|node| {
         !node
@@ -45,6 +76,59 @@ impl Document {
       .collect()
   }
 
+  pub fn resolve_selectors(&self, dot_path: &str) -> Vec<String> {
+    self.navigate_all_compact(dot_path).iter().map(node_selector).collect()
+  }
+
+  pub fn get_all_located(&self, dot_path: &str) -> Vec<LocatedNode> {
+    let source = self.root.text().to_string();
+    let file_path = self.path.as_ref().map(|p| p.to_string_lossy().to_string());
+
+    self
+      .navigate_all_compact(dot_path)
+      .iter()
+      .map(|node| {
+        let offset: usize = node.text_range().start().into();
+        let line = source[..offset].matches('\n').count() + 1;
+        let selector = node_selector(node);
+        let is_scalar = !node
+          .descendants()
+          .any(|child| child.kind() == SyntaxKind::BLOCK_MAP || child.kind() == SyntaxKind::BLOCK_SEQ);
+
+        let (text, value_type) = if is_scalar {
+          extract_scalar(node)
+            .map(|s| (Some(s.text.clone()), Some(crate::syntax::detect_yaml_type(&s))))
+            .unwrap_or((None, None))
+        } else {
+          (None, None)
+        };
+
+        let node_type = if is_scalar {
+          "scalar"
+        } else {
+          let map_pos = node.descendants().find_map(BlockMap::cast).map(|m| m.syntax().text_range().start());
+          let seq_pos = node.descendants().find_map(BlockSeq::cast).map(|s| s.syntax().text_range().start());
+
+          match (map_pos, seq_pos) {
+            (Some(m), Some(s)) if s < m => "sequence",
+            (Some(_), _) => "map",
+            (None, Some(_)) => "sequence",
+            _ => "map",
+          }
+        };
+
+        LocatedNode {
+          node_type: node_type.to_string(),
+          text,
+          value_type,
+          file_path: file_path.clone(),
+          selector,
+          line,
+        }
+      })
+      .collect()
+  }
+
   pub fn node_type(&self, dot_path: &str) -> NodeType {
     match self.navigate(dot_path) {
       Ok(node) => {
@@ -97,15 +181,43 @@ impl Document {
         key_name,
         key_location,
       },
-      None => NodeInfo {
-        node_type: self.node_type(dot_path),
-        is_list: false,
-        value: None,
-        list_values: vec![],
-        location,
-        key_name,
-        key_location,
-      },
+      None => {
+        let (node_type, entry_location, entry_key_name, entry_key_location) = if self.navigate(dot_path).is_err() {
+          if let Some(entry_node) = self.find_entry(dot_path) {
+            let range = entry_node.text_range();
+            let entry_location = compute_location(&source, range.start().into(), range.end().into());
+
+            let (node, location) = yaml_parser::ast::BlockMapEntry::cast(entry_node.clone())
+              .and_then(|entry| {
+                entry.key().and_then(|key_node| {
+                  let key_text = extract_scalar_text(key_node.syntax())?;
+                  let key_range = key_node.syntax().text_range();
+                  let key_location = compute_location(&source, key_range.start().into(), key_range.end().into());
+
+                  Some((key_text, key_location))
+                })
+              })
+              .map(|(name, location)| (Some(name), location))
+              .unwrap_or((None, Location::default()));
+
+            (NodeType::Scalar, entry_location, node, location)
+          } else {
+            (self.node_type(dot_path), location, key_name, key_location)
+          }
+        } else {
+          (self.node_type(dot_path), location, key_name, key_location)
+        };
+
+        NodeInfo {
+          node_type,
+          is_list: false,
+          value: None,
+          list_values: vec![],
+          location: entry_location,
+          key_name: entry_key_name,
+          key_location: entry_key_location,
+        }
+      }
     }
   }
 
@@ -166,28 +278,61 @@ impl Document {
       .collect()
   }
 
-  pub fn get_value(&self, dot_path: &str) -> Option<serde_yaml::Value> {
+  pub fn get_value(&self, dot_path: &str) -> Option<yaml_serde::Value> {
     if dot_path.is_empty() {
       return Some(node_to_yaml_value(&self.root));
     }
 
-    let nodes = self.navigate_all(dot_path);
+    let parsed = crate::selector::Selector::parse(dot_path);
 
-    if nodes.is_empty() {
-      return None;
-    }
+    if parsed.has_wildcard() {
+      let padded = self.navigate_all(dot_path);
 
-    if nodes.len() == 1 {
-      return Some(node_to_yaml_value(&nodes[0]));
-    }
+      if padded.is_empty() {
+        return None;
+      }
+
+      let values: Vec<yaml_serde::Value> = padded
+        .iter()
+        .map(|maybe_node| match maybe_node {
+          Some(node) => node_to_yaml_value(node),
+          None => yaml_serde::Value::Null,
+        })
+        .collect();
+
+      Some(yaml_serde::Value::Sequence(values))
+    } else {
+      let nodes = self.navigate_all_compact(dot_path);
 
-    let values: Vec<serde_yaml::Value> = nodes.iter().map(node_to_yaml_value).collect();
+      if nodes.is_empty() {
+        return None;
+      }
+
+      if nodes.len() == 1 {
+        return Some(node_to_yaml_value(&nodes[0]));
+      }
 
-    Some(serde_yaml::Value::Sequence(values))
+      let values: Vec<yaml_serde::Value> = nodes.iter().map(node_to_yaml_value).collect();
+
+      Some(yaml_serde::Value::Sequence(values))
+    }
   }
 
-  pub fn get_values(&self, dot_path: &str) -> Vec<serde_yaml::Value> {
-    self.navigate_all(dot_path).iter().map(node_to_yaml_value).collect()
+  pub fn get_values(&self, dot_path: &str) -> Vec<yaml_serde::Value> {
+    let parsed = crate::selector::Selector::parse(dot_path);
+
+    if parsed.has_wildcard() {
+      self
+        .navigate_all(dot_path)
+        .iter()
+        .map(|maybe_node| match maybe_node {
+          Some(node) => node_to_yaml_value(node),
+          None => yaml_serde::Value::Null,
+        })
+        .collect()
+    } else {
+      self.navigate_all_compact(dot_path).iter().map(node_to_yaml_value).collect()
+    }
   }
 
   pub fn selectors(&self) -> Vec<String> {
@@ -206,10 +351,33 @@ impl Document {
 
   pub fn exists(&self, dot_path: &str) -> bool {
     if dot_path.contains('[') {
-      return !self.navigate_all(dot_path).is_empty();
+      if !self.navigate_all_compact(dot_path).is_empty() {
+        return true;
+      }
+    } else if self.navigate(dot_path).is_ok() {
+      return true;
     }
 
-    self.get(dot_path).is_some()
+    self.find_entry(dot_path).is_some()
+  }
+
+  fn find_entry(&self, dot_path: &str) -> Option<SyntaxNode> {
+    let (parent_path, last_key) = match dot_path.rsplit_once('.') {
+      Some((parent, key)) => (parent, key),
+      None => ("", dot_path),
+    };
+
+    let parent_node = if parent_path.is_empty() {
+      let root = Root::cast(self.root.clone())?;
+      let document = root.documents().next()?;
+      document.syntax().clone()
+    } else {
+      self.navigate(parent_path).ok()?
+    };
+
+    let map = parent_node.descendants().find_map(BlockMap::cast)?;
+
+    find_entry_by_key(&map, last_key).map(|entry| entry.syntax().clone())
   }
 
   pub fn get_sequence_values(&self, dot_path: &str) -> Vec<String> {
@@ -260,3 +428,66 @@ impl Document {
     None
   }
 }
+
+pub(crate) fn node_selector(node: &SyntaxNode) -> String {
+  let mut parts: Vec<String> = Vec::new();
+  let mut current = node.clone();
+
+  if current.kind() == SyntaxKind::BLOCK_SEQ_ENTRY {
+    if let Some(parent) = current.parent() {
+      let index = parent
+        .children()
+        .filter(|child| child.kind() == SyntaxKind::BLOCK_SEQ_ENTRY)
+        .position(|child| child == current)
+        .unwrap_or(0);
+
+      parts.push(format!("[{}]", index));
+    }
+  }
+
+  loop {
+    let parent = match current.parent() {
+      Some(parent) => parent,
+      None => break,
+    };
+
+    match parent.kind() {
+      SyntaxKind::BLOCK_SEQ_ENTRY => {
+        if let Some(grandparent) = parent.parent() {
+          let index = grandparent
+            .children()
+            .filter(|child| child.kind() == SyntaxKind::BLOCK_SEQ_ENTRY)
+            .position(|child| child == parent)
+            .unwrap_or(0);
+
+          parts.push(format!("[{}]", index));
+        }
+      }
+
+      SyntaxKind::BLOCK_MAP_ENTRY => {
+        if let Some(key_node) = parent.children().find(|child| child.kind() == SyntaxKind::BLOCK_MAP_KEY) {
+          if let Some(key_text) = extract_scalar_text(&key_node) {
+            parts.push(key_text);
+          }
+        }
+      }
+
+      _ => {}
+    }
+
+    current = parent;
+  }
+
+  parts.reverse();
+  let mut result = String::new();
+
+  for part in &parts {
+    if !part.starts_with('[') && !result.is_empty() {
+      result.push('.');
+    }
+
+    result.push_str(part);
+  }
+
+  result
+}

data/rust/src/document/insert.rs

@@ -22,9 +22,9 @@ impl Document {
       }
     }
 
-    if let Some(serde_yaml::Value::Sequence(sequence)) = self.get_value(dot_path).as_ref() {
-      if let Some(serde_yaml::Value::Mapping(map)) = sequence.first() {
-        if let Some((serde_yaml::Value::String(key_name), _)) = map.iter().next() {
+    if let Some(yaml_serde::Value::Sequence(sequence)) = self.get_value(dot_path).as_ref() {
+      if let Some(yaml_serde::Value::Mapping(map)) = sequence.first() {
+        if let Some((yaml_serde::Value::String(key_name), _)) = map.iter().next() {
           let deep_path = if dot_path.is_empty() {
             format!("[].{}", key_name)
           } else {

data/rust/src/document/mod.rs

@@ -2,9 +2,24 @@ mod condition;
 mod delete;
 mod get;
 mod insert;
+mod schema;
 mod set;
 mod sort;
 mod style;
+mod unique;
+pub use unique::DuplicateInfo;
+
+use crate::syntax::YerbaValueType;
+
+#[derive(Debug, Clone)]
+pub struct LocatedNode {
+  pub node_type: String,
+  pub text: Option<String>,
+  pub value_type: Option<YerbaValueType>,
+  pub file_path: Option<String>,
+  pub selector: String,
+  pub line: usize,
+}
 
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -19,8 +34,8 @@ use crate::error::YerbaError;
 use crate::QuoteStyle;
 
 use crate::syntax::{
-  extract_scalar, extract_scalar_text, find_entry_by_key, find_scalar_token, format_scalar_value, is_map_key, is_yaml_non_string, preceding_whitespace_indent,
-  removal_range, unescape_double_quoted, unescape_single_quoted, ScalarValue,
+  dedent_block_scalar, extract_scalar, extract_scalar_text, find_entry_by_key, find_scalar_token, format_scalar_value, is_map_key, is_yaml_non_string,
+  preceding_whitespace_indent, removal_range, unescape_double_quoted, unescape_single_quoted, ScalarValue,
 };
 
 #[derive(Debug, Clone)]
@@ -155,7 +170,7 @@ impl Document {
       return Ok(document.syntax().clone());
     }
 
-    let nodes = self.navigate_all(dot_path);
+    let nodes = self.navigate_all_compact(dot_path);
 
     match nodes.len() {
       0 => Err(YerbaError::SelectorNotFound(dot_path.to_string())),
@@ -164,7 +179,11 @@ impl Document {
     }
   }
 
-  pub fn navigate_all(&self, dot_path: &str) -> Vec<SyntaxNode> {
+  pub fn navigate_all_compact(&self, dot_path: &str) -> Vec<SyntaxNode> {
+    self.navigate_all(dot_path).into_iter().flatten().collect()
+  }
+
+  pub fn navigate_all(&self, dot_path: &str) -> Vec<Option<SyntaxNode>> {
     if Document::validate_path(dot_path).is_err() {
       return Vec::new();
     }
@@ -181,26 +200,63 @@ impl Document {
       None => return Vec::new(),
     };
 
-    let mut current_nodes = vec![document.syntax().clone()];
+    let mut current_nodes: Vec<Option<SyntaxNode>> = vec![Some(document.syntax().clone())];
 
     if parsed.is_empty() {
       if let Some(sequence) = document.syntax().descendants().find_map(BlockSeq::cast) {
-        current_nodes = sequence.entries().map(|entry| entry.syntax().clone()).collect();
+        current_nodes = sequence.entries().map(|entry| Some(entry.syntax().clone())).collect();
       }
 
       return current_nodes;
     }
 
-    for segment in parsed.segments() {
-      let mut next_nodes = Vec::new();
-
-      for node in &current_nodes {
-        next_nodes.extend(resolve_segment(node, segment));
+    let segments = parsed.segments();
+
+    for (i, segment) in segments.iter().enumerate() {
+      let is_wildcard = matches!(segment, crate::selector::SelectorSegment::AllItems);
+      let has_remaining = i + 1 < segments.len();
+      let mut next_nodes: Vec<Option<SyntaxNode>> = Vec::new();
+
+      for maybe_node in &current_nodes {
+        match maybe_node {
+          None => next_nodes.push(None),
+          Some(node) => {
+            let resolved = resolve_segment(node, segment);
+
+            if is_wildcard && has_remaining {
+              let remaining = &segments[i + 1..];
+
+              for item in &resolved {
+                let results = navigate_remaining(item, remaining);
+
+                if results.is_empty() {
+                  next_nodes.push(None);
+                } else {
+                  for result in results {
+                    next_nodes.push(Some(result));
+                  }
+                }
+              }
+
+              return next_nodes;
+            } else if is_wildcard {
+              for item in resolved {
+                next_nodes.push(Some(item));
+              }
+            } else if resolved.is_empty() {
+              return Vec::new();
+            } else {
+              for item in resolved {
+                next_nodes.push(Some(item));
+              }
+            }
+          }
+        }
       }
 
       current_nodes = next_nodes;
 
-      if current_nodes.is_empty() {
+      if current_nodes.iter().all(|n| n.is_none()) {
         break;
       }
     }
@@ -389,11 +445,11 @@ pub(crate) fn compute_location(source: &str, start_offset: usize, end_offset: us
   }
 }
 
-pub fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mut Vec<String>) {
+pub fn collect_selectors(value: &yaml_serde::Value, prefix: &str, selectors: &mut Vec<String>) {
   match value {
-    serde_yaml::Value::Mapping(map) => {
+    yaml_serde::Value::Mapping(map) => {
       for (key, child) in map {
-        if let serde_yaml::Value::String(key_string) = key {
+        if let yaml_serde::Value::String(key_string) = key {
           let selector = if prefix.is_empty() {
             key_string.clone()
           } else {
@@ -406,7 +462,7 @@ pub fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mu
       }
     }
 
-    serde_yaml::Value::Sequence(sequence) => {
+    yaml_serde::Value::Sequence(sequence) => {
       let bracket_prefix = format!("{}[]", prefix);
       selectors.push(bracket_prefix.clone());
 
@@ -419,21 +475,21 @@ pub fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mu
   }
 }
 
-pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::Value {
+pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> yaml_serde::Value {
   if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
     let map_position = node.descendants().find_map(BlockMap::cast).map(|map| map.syntax().text_range().start());
 
     let sequence_position = sequence.syntax().text_range().start();
 
     if map_position.is_none() || sequence_position <= map_position.unwrap() {
-      let values: Vec<serde_yaml::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
+      let values: Vec<yaml_serde::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
 
-      return serde_yaml::Value::Sequence(values);
+      return yaml_serde::Value::Sequence(values);
     }
   }
 
   if let Some(map) = node.descendants().find_map(BlockMap::cast) {
-    let mut mapping = serde_yaml::Mapping::new();
+    let mut mapping = yaml_serde::Mapping::new();
 
     for entry in map.entries() {
       let key = entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())).unwrap_or_default();
@@ -441,18 +497,18 @@ pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::Value {
       let value = entry
         .value()
         .map(|value_node| node_to_yaml_value(value_node.syntax()))
-        .unwrap_or(serde_yaml::Value::Null);
+        .unwrap_or(yaml_serde::Value::Null);
 
-      mapping.insert(serde_yaml::Value::String(key), value);
+      mapping.insert(yaml_serde::Value::String(key), value);
     }
 
-    return serde_yaml::Value::Mapping(mapping);
+    return yaml_serde::Value::Mapping(mapping);
   }
 
   if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
-    let values: Vec<serde_yaml::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
+    let values: Vec<yaml_serde::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
 
-    return serde_yaml::Value::Sequence(values);
+    return yaml_serde::Value::Sequence(values);
   }
 
   if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
@@ -463,35 +519,37 @@ pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::Value {
       .map(|token| token.text().to_string())
       .unwrap_or_default();
 
-    return serde_yaml::Value::String(text);
+    let text = dedent_block_scalar(&text);
+
+    return yaml_serde::Value::String(text);
   }
 
   if let Some(scalar) = extract_scalar(node) {
     use crate::syntax::{detect_yaml_type, is_yaml_truthy, YerbaValueType};
 
     return match detect_yaml_type(&scalar) {
-      YerbaValueType::Null => serde_yaml::Value::Null,
-      YerbaValueType::Boolean => serde_yaml::Value::Bool(is_yaml_truthy(&scalar.text)),
+      YerbaValueType::Null => yaml_serde::Value::Null,
+      YerbaValueType::Boolean => yaml_serde::Value::Bool(is_yaml_truthy(&scalar.text)),
 
       YerbaValueType::Integer => scalar
         .text
         .parse::<i64>()
-        .map(|n| serde_yaml::Value::Number(serde_yaml::Number::from(n)))
-        .unwrap_or(serde_yaml::Value::String(scalar.text)),
+        .map(|n| yaml_serde::Value::Number(yaml_serde::Number::from(n)))
+        .unwrap_or(yaml_serde::Value::String(scalar.text)),
 
       YerbaValueType::Float => scalar
         .text
         .parse::<f64>()
-        .map(|n| serde_yaml::Value::Number(serde_yaml::Number::from(n)))
-        .unwrap_or(serde_yaml::Value::String(scalar.text)),
+        .map(|n| yaml_serde::Value::Number(yaml_serde::Number::from(n)))
+        .unwrap_or(yaml_serde::Value::String(scalar.text)),
 
-      YerbaValueType::String => serde_yaml::Value::String(scalar.text),
+      YerbaValueType::String => yaml_serde::Value::String(scalar.text),
     };
   }
 
   let text = node.text().to_string();
 
-  serde_yaml::from_str(&text).unwrap_or(serde_yaml::Value::String(text))
+  yaml_serde::from_str(&text).unwrap_or(yaml_serde::Value::String(text))
 }
 
 pub(crate) fn parse_condition(condition: &str) -> Option<(String, &str, String)> {
@@ -516,6 +574,26 @@ pub(crate) fn parse_condition(condition: &str) -> Option<(String, &str, String)>
   Some((left.to_string(), operator, right.to_string()))
 }
 
+fn navigate_remaining(node: &SyntaxNode, segments: &[crate::selector::SelectorSegment]) -> Vec<SyntaxNode> {
+  let mut current_nodes = vec![node.clone()];
+
+  for segment in segments {
+    let mut next_nodes = Vec::new();
+
+    for current in &current_nodes {
+      next_nodes.extend(resolve_segment(current, segment));
+    }
+
+    if next_nodes.is_empty() {
+      return Vec::new();
+    }
+
+    current_nodes = next_nodes;
+  }
+
+  current_nodes
+}
+
 fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment) -> Vec<SyntaxNode> {
   use crate::selector::SelectorSegment;