yerba 0.4.2 → 0.5.0

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,
+        }
+      }
     }
   }
 
@@ -171,23 +283,56 @@ impl Document {
       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<serde_yaml::Value> = padded
+        .iter()
+        .map(|maybe_node| match maybe_node {
+          Some(node) => node_to_yaml_value(node),
+          None => serde_yaml::Value::Null,
+        })
+        .collect();
+
+      Some(serde_yaml::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<serde_yaml::Value> = nodes.iter().map(node_to_yaml_value).collect();
+
+      Some(serde_yaml::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()
+    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 => serde_yaml::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/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;
       }
     }
@@ -463,6 +519,8 @@ pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::Value {
       .map(|token| token.text().to_string())
       .unwrap_or_default();
 
+    let text = dedent_block_scalar(&text);
+
     return serde_yaml::Value::String(text);
   }
 
@@ -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;
 

data/rust/src/document/schema.rs

@@ -0,0 +1,73 @@
+use super::*;
+
+impl Document {
+  pub fn validate_schema(&self, schema: &serde_json::Value, items: bool, selector: Option<&str>) -> Vec<crate::schema::ValidationError> {
+    let path = selector.unwrap_or("");
+    let has_wildcard = crate::selector::Selector::parse(path).has_wildcard();
+
+    let value = match self.get_value(path) {
+      Some(value) => crate::json::yaml_to_json(&value),
+      None => return vec![],
+    };
+
+    let validate_items = items || has_wildcard;
+
+    let mut errors = if validate_items {
+      match value.as_array() {
+        Some(array) => crate::schema::validate_array(array, schema),
+        None if value.is_null() => vec![crate::schema::ValidationError {
+          path: String::new(),
+          message: "expected an array but document is empty or not a sequence".to_string(),
+          item_label: None,
+          line: None,
+        }],
+        None => crate::schema::validate_array(std::slice::from_ref(&value), schema),
+      }
+    } else {
+      if value.is_null() {
+        return vec![];
+      }
+
+      crate::schema::validate_value(&value, schema)
+    };
+
+    let source = self.to_string();
+
+    for error in &mut errors {
+      if !error.path.is_empty() {
+        let selector = json_pointer_to_selector(&error.path);
+
+        if let Ok(node) = self.navigate(&selector) {
+          let offset: usize = node.text_range().start().into();
+          let line = source[..offset].chars().filter(|c| *c == '\n').count() + 1;
+
+          error.line = Some(line);
+        }
+      }
+    }
+
+    errors
+  }
+}
+
+fn json_pointer_to_selector(pointer: &str) -> String {
+  pointer
+    .strip_prefix('/')
+    .unwrap_or(pointer)
+    .split('/')
+    .map(|segment| {
+      if let Ok(index) = segment.parse::<usize>() {
+        format!("[{}]", index)
+      } else {
+        segment.to_string()
+      }
+    })
+    .fold(String::new(), |mut path, segment| {
+      if !path.is_empty() && !segment.starts_with('[') {
+        path.push('.');
+      }
+
+      path.push_str(&segment);
+      path
+    })
+}

data/rust/src/document/set.rs

@@ -26,7 +26,7 @@ impl Document {
   }
 
   pub fn set_all(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
-    let nodes = self.navigate_all(dot_path);
+    let nodes = self.navigate_all_compact(dot_path);
 
     if nodes.is_empty() {
       return Err(YerbaError::SelectorNotFound(dot_path.to_string()));

data/rust/src/document/sort.rs

@@ -113,12 +113,15 @@ impl Document {
       return self.validate_each_sort_keys(sequence_path, key_order);
     }
 
-    let current_node = self.navigate(dot_path)?;
+    let current_node = match self.navigate(dot_path) {
+      Ok(node) => node,
+      Err(_) => return Ok(()),
+    };
 
-    let map = current_node
-      .descendants()
-      .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let map = match current_node.descendants().find_map(BlockMap::cast) {
+      Some(map) => map,
+      None => return Ok(()),
+    };
 
     let unknown_keys: Vec<String> = map
       .entries()
@@ -138,12 +141,15 @@ impl Document {
       return self.sort_each_keys(sequence_path, key_order);
     }
 
-    let current_node = self.navigate(dot_path)?;
+    let current_node = match self.navigate(dot_path) {
+      Ok(node) => node,
+      Err(_) => return Ok(()),
+    };
 
-    let map = current_node
-      .descendants()
-      .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let map = match current_node.descendants().find_map(BlockMap::cast) {
+      Some(map) => map,
+      None => return Ok(()),
+    };
 
     let entries: Vec<_> = map.entries().collect();
 
@@ -202,7 +208,7 @@ impl Document {
         Err(_) => return Ok(()),
       }
     } else {
-      let found = self.navigate_all(dot_path);
+      let found = self.navigate_all_compact(dot_path);
       if found.is_empty() {
         return Ok(());
       }
@@ -307,7 +313,7 @@ impl Document {
         Err(_) => return Ok(()),
       }
     } else {
-      let found = self.navigate_all(dot_path);
+      let found = self.navigate_all_compact(dot_path);
       if found.is_empty() {
         return Ok(());
       }
@@ -438,7 +444,7 @@ impl Document {
       (dot_path, "")
     };
 
-    let parent_nodes = self.navigate_all(parent_path);
+    let parent_nodes = self.navigate_all_compact(parent_path);
     let source = self.root.text().to_string();
     let mut edits: Vec<(TextRange, String)> = Vec::new();
 

data/rust/src/document/style.rs

@@ -3,7 +3,7 @@ use super::*;
 impl Document {
   pub fn enforce_blank_lines(&mut self, dot_path: &str, blank_lines: usize) -> Result<(), YerbaError> {
     let nodes = if dot_path.contains('[') {
-      self.navigate_all(dot_path)
+      self.navigate_all_compact(dot_path)
     } else {
       vec![self.navigate(dot_path)?]
     };
@@ -105,7 +105,7 @@ impl Document {
     let source = self.root.text().to_string();
 
     let scope_ranges: Vec<TextRange> = match dot_path {
-      Some(path) if !path.is_empty() => self.navigate_all(path).iter().map(|node| node.text_range()).collect(),
+      Some(path) if !path.is_empty() => self.navigate_all_compact(path).iter().map(|node| node.text_range()).collect(),
       _ => vec![self.root.text_range()],
     };
 
@@ -219,7 +219,7 @@ impl Document {
     let source = self.root.text().to_string();
 
     let scope_ranges: Vec<TextRange> = match dot_path {
-      Some(path) if !path.is_empty() => self.navigate_all(path).iter().map(|node| node.text_range()).collect(),
+      Some(path) if !path.is_empty() => self.navigate_all_compact(path).iter().map(|node| node.text_range()).collect(),
       _ => vec![self.root.text_range()],
     };