yerba 0.7.6-x86_64-linux-gnu → 0.8.0-x86_64-linux-gnu

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

data/rust/src/document/get.rs

@@ -1,5 +1,26 @@
 use super::*;
 
+fn key_of(node: &SyntaxNode, source: &str) -> (Option<String>, Location) {
+  node
+    .parent()
+    .and_then(|parent| {
+      use yaml_parser::ast::{BlockMapEntry, FlowMapEntry};
+
+      let key_node = match BlockMapEntry::cast(parent.clone()) {
+        Some(entry) => entry.key().map(|key| key.syntax().clone()),
+        None => FlowMapEntry::cast(parent).and_then(|entry| entry.key().map(|key| key.syntax().clone())),
+      }?;
+
+      let key_text = extract_scalar_text(&key_node)?;
+      let key_range = key_node.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()))
+}
+
 impl Document {
   pub fn is_valid_selector(&self, dot_path: &str) -> bool {
     if dot_path.is_empty() {
@@ -12,6 +33,10 @@ impl Document {
       return true;
     }
 
+    if crate::selector::Selector::parse(dot_path).has_wildcard() && !self.navigate_all_compact(dot_path).is_empty() {
+      return true;
+    }
+
     let wildcard_version = dot_path.replace(|c: char| c.is_ascii_digit(), "").replace("[.", "[");
 
     let mut normalized = String::new();
@@ -82,6 +107,49 @@ impl Document {
     self.navigate_all_compact(dot_path).iter().map(node_selector).collect()
   }
 
+  pub fn keys_at(&self, dot_path: &str) -> Vec<String> {
+    let node = if dot_path.is_empty() {
+      self.root.clone()
+    } else {
+      match self.navigate_all_compact(dot_path).into_iter().next() {
+        Some(node) => node,
+        None => return Vec::new(),
+      }
+    };
+
+    let collection = node.descendants().find(|descendant| {
+      matches!(
+        descendant.kind(),
+        SyntaxKind::BLOCK_MAP | SyntaxKind::BLOCK_SEQ | SyntaxKind::FLOW_MAP | SyntaxKind::FLOW_SEQ
+      )
+    });
+
+    let Some(collection) = collection else {
+      return Vec::new();
+    };
+
+    if let Some(map) = BlockMap::cast(collection.clone()) {
+      return map
+        .entries()
+        .filter_map(|entry| entry.key().and_then(|key| extract_scalar_text(key.syntax())))
+        .collect();
+    }
+
+    if let Some(map) = yaml_parser::ast::FlowMap::cast(collection) {
+      return map
+        .entries()
+        .map(|entries| {
+          entries
+            .entries()
+            .filter_map(|entry| entry.key().and_then(|key| extract_scalar_text(key.syntax())))
+            .collect()
+        })
+        .unwrap_or_default();
+    }
+
+    Vec::new()
+  }
+
   pub fn get_all_located(&self, dot_path: &str) -> Vec<LocatedNode> {
     let source = self.source_text();
     let file_path = self.path.as_ref().map(|p| p.to_string_lossy().to_string());
@@ -116,6 +184,8 @@ impl Document {
           }
         };
 
+        let (key_name, key_location) = key_of(node, &source);
+
         LocatedNode {
           node_type: node_type.to_string(),
           text,
@@ -124,6 +194,8 @@ impl Document {
           selector,
           line,
           location,
+          key_name,
+          key_location,
         }
       })
       .collect()
@@ -214,23 +286,7 @@ impl Document {
         let range = node.text_range();
         let location = compute_location(source, range.start().into(), range.end().into());
 
-        let (key_name, key_location) = node
-          .parent()
-          .and_then(|parent| {
-            use yaml_parser::ast::BlockMapEntry;
-
-            BlockMapEntry::cast(parent).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()));
+        let (key_name, key_location) = key_of(&node, source);
 
         (location, key_name, key_location)
       }
@@ -238,15 +294,15 @@ impl Document {
     }
   }
 
-  pub fn find_items(&self, dot_path: &str, condition: Option<&str>, select: Option<&str>) -> Vec<serde_json::Value> {
+  pub fn find_items(&self, dot_path: &str, condition: Option<&str>, select: Option<&str>) -> Result<Vec<serde_json::Value>, YerbaError> {
     let values = match condition {
-      Some(cond) => self.filter(dot_path, cond),
+      Some(cond) => self.filter(dot_path, cond)?,
       None => self.get_values(dot_path),
     };
 
     let select_fields: Option<Vec<&str>> = select.map(|s| s.split(',').collect());
 
-    values
+    let items = values
       .iter()
       .map(|value| match &select_fields {
         Some(fields) => {
@@ -262,7 +318,9 @@ impl Document {
         }
         None => crate::json::yaml_to_json(value),
       })
-      .collect()
+      .collect();
+
+    Ok(items)
   }
 
   pub fn get_value(&self, dot_path: &str) -> Option<yaml_serde::Value> {
@@ -337,7 +395,7 @@ impl Document {
   }
 
   pub fn exists(&self, dot_path: &str) -> bool {
-    if dot_path.contains('[') {
+    if crate::selector::Selector::parse(dot_path).has_wildcard() {
       if !self.navigate_all_compact(dot_path).is_empty() {
         return true;
       }
@@ -455,11 +513,13 @@ 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 matches!(current.kind(), SyntaxKind::BLOCK_SEQ_ENTRY | SyntaxKind::FLOW_SEQ_ENTRY) {
     if let Some(parent) = current.parent() {
+      let kind = current.kind();
+
       let index = parent
         .children()
-        .filter(|child| child.kind() == SyntaxKind::BLOCK_SEQ_ENTRY)
+        .filter(|child| child.kind() == kind)
         .position(|child| child == current)
         .unwrap_or(0);
 
@@ -474,11 +534,11 @@ pub(crate) fn node_selector(node: &SyntaxNode) -> String {
     };
 
     match parent.kind() {
-      SyntaxKind::BLOCK_SEQ_ENTRY => {
+      SyntaxKind::BLOCK_SEQ_ENTRY | SyntaxKind::FLOW_SEQ_ENTRY => {
         if let Some(grandparent) = parent.parent() {
           let index = grandparent
             .children()
-            .filter(|child| child.kind() == SyntaxKind::BLOCK_SEQ_ENTRY)
+            .filter(|child| child.kind() == parent.kind())
             .position(|child| child == parent)
             .unwrap_or(0);
 
@@ -494,6 +554,14 @@ pub(crate) fn node_selector(node: &SyntaxNode) -> String {
         }
       }
 
+      SyntaxKind::FLOW_MAP_ENTRY => {
+        if let Some(key_node) = parent.children().find(|child| child.kind() == SyntaxKind::FLOW_MAP_KEY) {
+          if let Some(key_text) = extract_scalar_text(&key_node) {
+            parts.push(key_text);
+          }
+        }
+      }
+
       _ => {}
     }
 

data/rust/src/document/insert.rs

@@ -90,6 +90,28 @@ impl Document {
 
   pub fn insert_into(&mut self, dot_path: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
     Self::validate_path(dot_path)?;
+    self.refuse_flow_target(dot_path)?;
+
+    if let Some((parent_path, _)) = dot_path.rsplit_once('.') {
+      if let Ok(parent) = self.navigate(parent_path) {
+        let occupied_flow = find_flow_map(&parent).map(|map| !flow_map_entries(&map).is_empty()).unwrap_or(false)
+          || find_flow_sequence(&parent)
+            .map(|sequence| !flow_sequence_entries(&sequence).is_empty())
+            .unwrap_or(false);
+
+        if occupied_flow {
+          return Err(YerbaError::FlowCollectionNotWritable(dot_path.to_string()));
+        }
+      }
+    }
+
+    if crate::selector::Selector::parse(dot_path)
+      .segments()
+      .iter()
+      .any(|segment| matches!(segment, crate::selector::SelectorSegment::AllKeys))
+    {
+      return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
+    }
 
     if let Ok(current_node) = self.navigate(dot_path) {
       if find_block_sequence(&current_node).is_some()

data/rust/src/document/mod.rs

@@ -1,4 +1,5 @@
 mod condition;
+pub use condition::{validate_condition, validate_item_condition};
 mod delete;
 mod get;
 mod insert;
@@ -20,6 +21,8 @@ pub struct LocatedNode {
   pub selector: String,
   pub line: usize,
   pub location: Location,
+  pub key_name: Option<String>,
+  pub key_location: Location,
 }
 
 use std::fs;
@@ -35,9 +38,10 @@ use crate::error::YerbaError;
 use crate::QuoteStyle;
 
 use crate::syntax::{
-  column_at, dedent_block_scalar, extract_scalar, extract_scalar_text, find_block_map, find_block_sequence, find_entry_by_key, find_scalar_token,
-  first_collection, format_scalar_value, is_map_key, is_yaml_non_string, line_at, line_start_at, preceding_whitespace_indent, preceding_whitespace_token,
-  raw_scalar_value, removal_range, FirstCollection, ScalarValue,
+  column_at, dedent_block_scalar, extract_scalar, extract_scalar_text, find_block_map, find_block_sequence, find_entry_by_key, find_flow_entry_by_key,
+  find_flow_map, find_flow_sequence, find_scalar_token, first_collection, flow_map_entries, flow_sequence_entries, format_scalar_value, in_flow_collection,
+  is_map_key, is_yaml_non_string, line_at, line_start_at, preceding_whitespace_indent, preceding_whitespace_token, raw_scalar_value, removal_range,
+  FirstCollection, ScalarValue,
 };
 
 #[derive(Debug, Clone)]
@@ -190,6 +194,14 @@ impl Document {
     self.navigate_all(dot_path).into_iter().flatten().collect()
   }
 
+  pub(crate) fn refuse_flow_target(&self, dot_path: &str) -> Result<(), YerbaError> {
+    if self.navigate_all_compact(dot_path).iter().any(in_flow_collection) {
+      return Err(YerbaError::FlowCollectionNotWritable(dot_path.to_string()));
+    }
+
+    Ok(())
+  }
+
   pub fn navigate_all(&self, dot_path: &str) -> Vec<Option<SyntaxNode>> {
     if Document::validate_path(dot_path).is_err() {
       return Vec::new();
@@ -220,7 +232,7 @@ impl Document {
     let segments = parsed.segments();
 
     for (i, segment) in segments.iter().enumerate() {
-      let is_wildcard = matches!(segment, crate::selector::SelectorSegment::AllItems);
+      let is_wildcard = matches!(segment, crate::selector::SelectorSegment::AllItems | crate::selector::SelectorSegment::AllKeys);
       let has_remaining = i + 1 < segments.len();
       let mut next_nodes: Vec<Option<SyntaxNode>> = Vec::new();
 
@@ -335,22 +347,28 @@ impl Document {
       return self.remove_node(entry_node);
     }
 
-    let end = if let Some(next_sibling) = entry_node.next_sibling() {
-      next_sibling.text_range().start()
-    } else {
-      entry_node.parent().map(|parent| parent.text_range().end()).unwrap_or(entry_range.end())
-    };
+    let source = self.source_text();
 
-    let start = if let Some(whitespace_token) = preceding_whitespace_token(entry_node) {
-      let whitespace_text = whitespace_token.text();
-      let whitespace_start = whitespace_token.text_range().start();
+    let (start, end) = match preceding_whitespace_token(entry_node) {
+      Some(whitespace_token) => {
+        let whitespace_text = whitespace_token.text();
+        let whitespace_start = whitespace_token.text_range().start();
 
-      whitespace_text
-        .rfind('\n')
-        .map(|offset| whitespace_start + TextSize::from(offset as u32))
-        .unwrap_or(whitespace_start)
-    } else {
-      entry_range.start()
+        let start = whitespace_text
+          .rfind('\n')
+          .map(|offset| whitespace_start + TextSize::from(offset as u32))
+          .unwrap_or(whitespace_start);
+
+        (start, entry_range.end())
+      }
+
+      None => {
+        let entry_end: usize = entry_range.end().into();
+        let line_start = line_start_at(&source, entry_range.start().into());
+        let after_entry = source[entry_end..].find('\n').map(|offset| entry_end + offset + 1).unwrap_or(entry_end);
+
+        (TextSize::from(line_start as u32), TextSize::from(after_entry as u32))
+      }
     };
 
     self.apply_edit(TextRange::new(start, end), "")
@@ -673,6 +691,8 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
     SelectorSegment::AllItems => {
       if let Some(sequence) = find_block_sequence(node) {
         sequence.entries().map(|entry| entry.syntax().clone()).collect()
+      } else if let Some(sequence) = find_flow_sequence(node) {
+        flow_sequence_entries(&sequence)
       } else {
         Vec::new()
       }
@@ -681,6 +701,25 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
     SelectorSegment::Index(index) => {
       if let Some(sequence) = find_block_sequence(node) {
         sequence.entries().nth(*index).map(|entry| vec![entry.syntax().clone()]).unwrap_or_default()
+      } else if let Some(sequence) = find_flow_sequence(node) {
+        flow_sequence_entries(&sequence)
+          .into_iter()
+          .nth(*index)
+          .map(|entry| vec![entry])
+          .unwrap_or_default()
+      } else {
+        Vec::new()
+      }
+    }
+
+    SelectorSegment::AllKeys => {
+      if let Some(map) = find_block_map(node) {
+        map.entries().filter_map(|entry| entry.value().map(|value| value.syntax().clone())).collect()
+      } else if let Some(map) = find_flow_map(node) {
+        flow_map_entries(&map)
+          .into_iter()
+          .filter_map(|entry| entry.value().map(|value| value.syntax().clone()))
+          .collect()
       } else {
         Vec::new()
       }
@@ -693,6 +732,16 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
             return vec![value.syntax().clone()];
           }
         }
+
+        return Vec::new();
+      }
+
+      if let Some(map) = find_flow_map(node) {
+        if let Some(entry) = find_flow_entry_by_key(&map, key) {
+          if let Some(value) = entry.value() {
+            return vec![value.syntax().clone()];
+          }
+        }
       }
 
       Vec::new()

data/rust/src/document/set.rs

@@ -1,5 +1,70 @@
 use super::*;
 
+fn holds_collection(node: &SyntaxNode) -> bool {
+  node.descendants().any(|descendant| {
+    matches!(
+      descendant.kind(),
+      SyntaxKind::BLOCK_MAP | SyntaxKind::BLOCK_SEQ | SyntaxKind::FLOW_MAP | SyntaxKind::FLOW_SEQ
+    )
+  })
+}
+
+struct ValueSpan {
+  range: TextRange,
+  separated: bool,
+  comment: Option<String>,
+}
+
+fn value_span(node: &SyntaxNode) -> Option<ValueSpan> {
+  let (container, separator_kind) = match node.kind() {
+    SyntaxKind::BLOCK_MAP_VALUE | SyntaxKind::FLOW_MAP_VALUE => (node.parent()?, SyntaxKind::COLON),
+    SyntaxKind::BLOCK_SEQ_ENTRY => (node.clone(), SyntaxKind::MINUS),
+
+    SyntaxKind::FLOW_SEQ_ENTRY => {
+      return Some(ValueSpan {
+        range: node.text_range(),
+        separated: false,
+        comment: None,
+      })
+    }
+
+    _ => return None,
+  };
+
+  let mut elements = container
+    .children_with_tokens()
+    .skip_while(|element| element.as_token().map(|token| token.kind() != separator_kind).unwrap_or(true));
+
+  let separator = elements.next()?.into_token()?;
+  let mut comment = None;
+
+  for element in elements {
+    match element.into_token() {
+      Some(token) if token.kind() == SyntaxKind::COMMENT => comment = Some(token.text().trim_end().to_string()),
+      Some(token) if token.kind() == SyntaxKind::WHITESPACE && token.text().contains('\n') => break,
+      Some(_) => {}
+      None => break,
+    }
+  }
+
+  Some(ValueSpan {
+    range: TextRange::new(separator.text_range().end(), node.text_range().end()),
+    separated: true,
+    comment,
+  })
+}
+
+fn replacement_text(span: &ValueSpan, value: &str) -> String {
+  let mut text = if span.separated { format!(" {}", value) } else { value.to_string() };
+
+  if let Some(comment) = &span.comment {
+    text.push(' ');
+    text.push_str(comment);
+  }
+
+  text
+}
+
 impl Document {
   pub fn set(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
     let current_node = self.navigate(dot_path)?;
@@ -11,6 +76,12 @@ impl Document {
       return self.apply_edit(block_scalar.text_range(), &new_text);
     }
 
+    if holds_collection(&current_node) {
+      let span = value_span(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+      return self.apply_edit(span.range, &replacement_text(&span, value));
+    }
+
     let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     let new_text = format_scalar_value(value, scalar_token.kind());
@@ -31,6 +102,10 @@ impl Document {
     for node in nodes {
       if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
         edits.push((block_scalar.text_range(), Self::block_scalar_replacement(&source, &block_scalar, value)));
+      } else if holds_collection(&node) {
+        if let Some(span) = value_span(&node) {
+          edits.push((span.range, replacement_text(&span, value)));
+        }
       } else if let Some(scalar_token) = find_scalar_token(&node) {
         edits.push((scalar_token.text_range(), format_scalar_value(value, scalar_token.kind())));
       }
@@ -68,6 +143,12 @@ impl Document {
       return self.apply_edit(range, value);
     }
 
+    if holds_collection(&current_node) {
+      let span = value_span(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+      return self.apply_edit(span.range, &replacement_text(&span, value));
+    }
+
     let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     self.replace_token(&scalar_token, value)

data/rust/src/error.rs

@@ -4,7 +4,9 @@ pub enum YerbaError {
   IoError(std::io::Error),
   SelectorNotFound(String),
   AmbiguousSelector(String, usize),
+  InvalidCondition(String, String),
   NotASequence(String),
+  FlowCollectionNotWritable(String),
   IndexOutOfBounds(usize, usize),
   UnknownKeys(Vec<String>),
   DuplicateValues(Vec<crate::DuplicateInfo>),
@@ -25,6 +27,14 @@ impl std::fmt::Display for YerbaError {
       YerbaError::SelectorNotFound(selector) => write!(f, "selector not found: {}", selector),
       YerbaError::NotASequence(path) => write!(f, "not a sequence: {}", path),
 
+      YerbaError::FlowCollectionNotWritable(path) => {
+        write!(
+          f,
+          "cannot write to \"{}\": flow collections are not writable yet. Convert it to block style first, with `collection_style` or `yerba collection-style`",
+          path
+        )
+      }
+
       YerbaError::AmbiguousSelector(selector, count) => {
         write!(
           f,
@@ -33,6 +43,10 @@ impl std::fmt::Display for YerbaError {
         )
       }
 
+      YerbaError::InvalidCondition(condition, reason) => {
+        write!(f, "invalid condition \"{}\": {}", condition, reason)
+      }
+
       YerbaError::DuplicateKey {
         key,
         first_line,

data/rust/src/ffi.rs

@@ -330,6 +330,24 @@ pub unsafe extern "C" fn yerba_document_resolve_selectors(document: *const Docum
   CString::new(json_string).unwrap_or_default().into_raw()
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn yerba_selector_has_wildcard(path: *const c_char) -> bool {
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+
+  crate::selector::Selector::parse(selector_string).has_wildcard()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_keys(document: *const Document, path: *const c_char) -> *mut c_char {
+  let document = &*document;
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+
+  let keys = document.keys_at(selector_string);
+  let json_string = serde_json::to_string(&keys).unwrap_or_else(|_| "[]".to_string());
+
+  CString::new(json_string).unwrap_or_default().into_raw()
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_get_quote_style(document: *const Document, path: *const c_char) -> *mut c_char {
   let document = &*document;
@@ -409,12 +427,33 @@ pub unsafe extern "C" fn yerba_document_set_sequence_indent(document: *mut Docum
   }
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn yerba_validate_condition(condition: *const c_char, item_context: bool) -> *mut c_char {
+  if condition.is_null() {
+    return ptr::null_mut();
+  }
+
+  let cond = CStr::from_ptr(condition).to_str().unwrap_or("");
+
+  let result = if item_context {
+    crate::validate_item_condition(cond)
+  } else {
+    crate::validate_condition(cond)
+  };
+
+  match result {
+    Ok(()) => ptr::null_mut(),
+    Err(error) => CString::new(error.to_string()).unwrap_or_default().into_raw(),
+  }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_evaluate_condition(document: *const Document, parent_path: *const c_char, condition: *const c_char) -> bool {
   let document = &*document;
   let parent = CStr::from_ptr(parent_path).to_str().unwrap_or("");
   let cond = CStr::from_ptr(condition).to_str().unwrap_or("");
-  document.evaluate_condition(parent, cond)
+
+  document.evaluate_condition(parent, cond).unwrap_or(false)
 }
 
 #[no_mangle]
@@ -440,7 +479,7 @@ pub unsafe extern "C" fn yerba_document_find(document: *const Document, path: *c
 
   let select_string = if select.is_null() { None } else { CStr::from_ptr(select).to_str().ok() };
 
-  let results = document.find_items(selector_string, condition_string, select_string);
+  let results = document.find_items(selector_string, condition_string, select_string).unwrap_or_default();
   let json = serde_json::to_string_pretty(&results).unwrap_or_else(|_| "[]".to_string());
 
   CString::new(json).unwrap_or_default().into_raw()
@@ -830,12 +869,7 @@ pub unsafe extern "C" fn yerba_get_result_free(result: YerbaGetResult) {
   }
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *const c_char) -> YerbaTypedList {
-  let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
-  let nodes = crate::glob_get(pattern, selector_string);
-
+fn located_nodes_to_list(nodes: &[crate::LocatedNode]) -> YerbaTypedList {
   let results: Vec<serde_json::Value> = nodes
     .iter()
     .map(|node| {
@@ -865,6 +899,18 @@ pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *cons
         value["type"] = serde_json::json!(vt as u8);
       }
 
+      if let Some(key_name) = &node.key_name {
+        value["key_name"] = serde_json::json!(key_name);
+        value["key_location"] = serde_json::json!({
+          "start_line": node.key_location.start_line,
+          "start_column": node.key_location.start_column,
+          "end_line": node.key_location.end_line,
+          "end_column": node.key_location.end_column,
+          "start_offset": node.key_location.start_offset,
+          "end_offset": node.key_location.end_offset,
+        });
+      }
+
       value
     })
     .collect();
@@ -878,6 +924,22 @@ pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *cons
   }
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *const c_char) -> YerbaTypedList {
+  let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+
+  located_nodes_to_list(&crate::glob_get(pattern, selector_string))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_get_all(document: *const Document, path: *const c_char) -> YerbaTypedList {
+  let document = &*document;
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+
+  located_nodes_to_list(&document.get_all_located(selector_string))
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_glob_find(glob_pattern: *const c_char, path: *const c_char, condition: *const c_char, select: *const c_char) -> YerbaTypedList {
   let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");
@@ -885,7 +947,7 @@ pub unsafe extern "C" fn yerba_glob_find(glob_pattern: *const c_char, path: *con
   let condition_string = if condition.is_null() { None } else { CStr::from_ptr(condition).to_str().ok() };
   let select_string = if select.is_null() { None } else { CStr::from_ptr(select).to_str().ok() };
 
-  let all_results = crate::glob_find(pattern, selector_string, condition_string, select_string);
+  let all_results = crate::glob_find(pattern, selector_string, condition_string, select_string).unwrap_or_default();
   let length = all_results.len();
   let json = serde_json::to_string_pretty(&all_results).unwrap_or_else(|_| "[]".to_string());