yerba 0.9.1-arm-linux-gnu → 0.10.0-arm-linux-gnu

data/rust/src/ffi.rs

@@ -12,7 +12,7 @@ use std::ffi::{CStr, CString};
 use std::os::raw::c_char;
 use std::ptr;
 
-use crate::syntax::{detect_yaml_type, YerbaValueType};
+use crate::syntax::{detect_yaml_type, resolve_plain_scalar, PlainScalar, YerbaValueType};
 use crate::NodeType;
 use crate::{Document, InsertPosition, QuoteStyle};
 
@@ -44,6 +44,30 @@ pub struct YerbaTypedValue {
   pub value_type: YerbaValueType,
 }
 
+impl YerbaTypedValue {
+  fn new(text: &str, value_type: YerbaValueType) -> Self {
+    YerbaTypedValue {
+      text: CString::new(typed_text(text, value_type)).unwrap_or_default().into_raw(),
+      value_type,
+    }
+  }
+}
+
+fn typed_text(text: &str, value_type: YerbaValueType) -> String {
+  if value_type == YerbaValueType::String {
+    return text.to_string();
+  }
+
+  match resolve_plain_scalar(text) {
+    PlainScalar::Boolean(boolean) => boolean.to_string(),
+    PlainScalar::Integer(integer) => integer.to_string(),
+    PlainScalar::Float(float) if float.is_nan() => ".nan".to_string(),
+    PlainScalar::Float(float) if float.is_infinite() => (if float > 0.0 { ".inf" } else { "-.inf" }).to_string(),
+    PlainScalar::Float(float) => format!("{:?}", float),
+    PlainScalar::Null | PlainScalar::String => text.to_string(),
+  }
+}
+
 #[repr(C)]
 pub struct YerbaTypedList {
   pub json: *mut c_char,
@@ -64,6 +88,26 @@ pub struct YerbaLocation {
   pub start_column: usize,
   pub end_line: usize,
   pub end_column: usize,
+  pub start_character_column: usize,
+  pub end_character_column: usize,
+}
+
+#[repr(C)]
+pub struct YerbaNodeRecord {
+  pub parent: isize,
+  pub node_type: NodeType,
+  pub selector: *mut c_char,
+  pub key_name: *mut c_char,
+  pub value: YerbaTypedValue,
+  pub has_value: bool,
+  pub location: YerbaLocation,
+  pub key_location: YerbaLocation,
+}
+
+#[repr(C)]
+pub struct YerbaNodeList {
+  pub records: *mut YerbaNodeRecord,
+  pub length: usize,
 }
 
 #[repr(C)]
@@ -116,11 +160,7 @@ impl YerbaGetResult {
 
   fn scalar(mut self, text: &str, value_type: YerbaValueType) -> Self {
     self.node_type = NodeType::Scalar;
-
-    self.single = YerbaTypedValue {
-      text: CString::new(text).unwrap_or_default().into_raw(),
-      value_type,
-    };
+    self.single = YerbaTypedValue::new(text, value_type);
 
     self
   }
@@ -215,6 +255,8 @@ const EMPTY_LOCATION: YerbaLocation = YerbaLocation {
   start_column: 0,
   end_line: 0,
   end_column: 0,
+  start_character_column: 0,
+  end_character_column: 0,
 };
 
 #[no_mangle]
@@ -230,11 +272,11 @@ pub unsafe extern "C" fn yerba_document_free(document: *mut Document) {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_get(document: *const Document, path: *const c_char) -> YerbaGetResult {
+pub unsafe extern "C" fn yerba_document_get(document: *const Document, selector: *const c_char) -> YerbaGetResult {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
-  if let Err(e) = Document::validate_path(selector_string) {
+  if let Err(e) = Document::validate_selector(selector_string) {
     return YerbaGetResult::with_error(&e.to_string());
   }
 
@@ -255,7 +297,7 @@ pub unsafe extern "C" fn yerba_document_get(document: *const Document, path: *co
       .iter()
       .map(|value| {
         serde_json::json!({
-          "text": value.text,
+          "text": typed_text(&value.text, detect_yaml_type(value)),
           "type": detect_yaml_type(value) as u8
         })
       })
@@ -280,14 +322,29 @@ fn location_to_ffi(location: crate::Location) -> YerbaLocation {
     start_column: location.start_column,
     end_line: location.end_line,
     end_column: location.end_column,
+    start_character_column: location.start_character_column,
+    end_character_column: location.end_character_column,
   }
 }
 
+fn location_json(location: &crate::Location) -> serde_json::Value {
+  serde_json::json!({
+    "start_line": location.start_line,
+    "start_column": location.start_column,
+    "end_line": location.end_line,
+    "end_column": location.end_column,
+    "start_offset": location.start_offset,
+    "end_offset": location.end_offset,
+    "start_character_column": location.start_character_column,
+    "end_character_column": location.end_character_column,
+  })
+}
+
 /// Caller must free with yerba_string_free.
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_source(document: *const Document, path: *const c_char) -> *mut c_char {
+pub unsafe extern "C" fn yerba_document_source(document: *const Document, selector: *const c_char) -> *mut c_char {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   match document.source(selector_string) {
     Ok(text) => CString::new(text).unwrap_or_default().into_raw(),
@@ -297,14 +354,13 @@ pub unsafe extern "C" fn yerba_document_source(document: *const Document, path:
 
 /// Caller must free with yerba_string_free.
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_get_value(document: *const Document, path: *const c_char) -> *mut c_char {
+pub unsafe extern "C" fn yerba_document_get_value(document: *const Document, selector: *const c_char) -> *mut c_char {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   match document.get_value(selector_string) {
     Some(value) => {
-      let json = crate::json::yaml_to_json(&value);
-      let json_string = serde_json::to_string(&json).unwrap_or_else(|_| "null".to_string());
+      let json_string = crate::json::yaml_to_json_string_allowing_nan(&value);
 
       CString::new(json_string).unwrap_or_default().into_raw()
     }
@@ -325,9 +381,9 @@ pub unsafe extern "C" fn yerba_document_selectors(document: *const Document) ->
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_resolve_selectors(document: *const Document, path: *const c_char) -> *mut c_char {
+pub unsafe extern "C" fn yerba_document_resolve_selectors(document: *const Document, selector: *const c_char) -> *mut c_char {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   let selectors = document.resolve_selectors(selector_string);
   let json_string = serde_json::to_string(&selectors).unwrap_or_else(|_| "[]".to_string());
@@ -336,16 +392,78 @@ pub unsafe extern "C" fn yerba_document_resolve_selectors(document: *const Docum
 }
 
 #[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("");
+pub unsafe extern "C" fn yerba_selector_has_wildcard(selector: *const c_char) -> bool {
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   crate::selector::Selector::parse(selector_string).has_wildcard()
 }
 
+/// Parses a selector into JSON: `{"relative": bool, "segments": [...]}`.
+///
+/// Keys are encoded as strings, indexes as integers (negative from the end), `[]` as `{"all": "items"}` and `*` as `{"all": "keys"}`.
+#[no_mangle]
+pub unsafe extern "C" fn yerba_selector_parse(selector: *const c_char) -> *mut c_char {
+  use crate::selector::{Selector, SelectorSegment};
+
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
+  let selector = Selector::parse(selector_string);
+
+  let segments: Vec<serde_json::Value> = selector
+    .segments()
+    .iter()
+    .map(|segment| match segment {
+      SelectorSegment::Key(key) => serde_json::json!(key),
+      SelectorSegment::Index(index) => serde_json::json!(index),
+      SelectorSegment::IndexFromEnd(offset) => serde_json::json!(-(*offset.min(&(i64::MAX as usize)) as i64)),
+      SelectorSegment::AllItems => serde_json::json!({ "all": "items" }),
+      SelectorSegment::AllKeys => serde_json::json!({ "all": "keys" }),
+    })
+    .collect();
+
+  let json = serde_json::json!({ "relative": selector.is_relative(), "segments": segments });
+
+  CString::new(json.to_string()).unwrap_or_default().into_raw()
+}
+
+/// Builds a selector string from a JSON array of segments, encoded like `yerba_selector_parse` returns them.
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_keys(document: *const Document, path: *const c_char) -> *mut c_char {
+pub unsafe extern "C" fn yerba_selector_build(segments_json: *const c_char, relative: bool) -> *mut c_char {
+  use crate::selector::{Selector, SelectorSegment};
+
+  let json_string = CStr::from_ptr(segments_json).to_str().unwrap_or("[]");
+  let values: Vec<serde_json::Value> = serde_json::from_str(json_string).unwrap_or_default();
+
+  let segments: Vec<SelectorSegment> = values
+    .iter()
+    .filter_map(|value| match value {
+      serde_json::Value::String(key) => Some(SelectorSegment::Key(key.clone())),
+      serde_json::Value::Number(number) => match number.as_i64() {
+        Some(index) if index < 0 => Some(SelectorSegment::IndexFromEnd(index.unsigned_abs() as usize)),
+        _ => number.as_u64().map(|index| SelectorSegment::Index(index as usize)),
+      },
+      serde_json::Value::Object(object) => match object.get("all").and_then(|all| all.as_str()) {
+        Some("items") => Some(SelectorSegment::AllItems),
+        Some("keys") => Some(SelectorSegment::AllKeys),
+        _ => None,
+      },
+      _ => None,
+    })
+    .collect();
+
+  let selector_string = Selector::Absolute(segments).to_selector_string();
+  let selector_string = if relative && !selector_string.is_empty() {
+    format!(".{}", selector_string)
+  } else {
+    selector_string
+  };
+
+  CString::new(selector_string).unwrap_or_default().into_raw()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_keys(document: *const Document, selector: *const c_char) -> *mut c_char {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   let keys = document.keys_at(selector_string);
   let json_string = serde_json::to_string(&keys).unwrap_or_else(|_| "[]".to_string());
@@ -354,9 +472,9 @@ pub unsafe extern "C" fn yerba_document_keys(document: *const Document, path: *c
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_get_quote_style(document: *const Document, path: *const c_char) -> *mut c_char {
+pub unsafe extern "C" fn yerba_document_get_quote_style(document: *const Document, selector: *const c_char) -> *mut c_char {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   match document.get_quote_style(selector_string) {
     Some(style) => {
@@ -370,9 +488,9 @@ pub unsafe extern "C" fn yerba_document_get_quote_style(document: *const Documen
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_set_quote_style(document: *mut Document, path: *const c_char, style: *const c_char) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_set_quote_style(document: *mut Document, selector: *const c_char, style: *const c_char) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   let style_string = &CStr::from_ptr(style).to_str().unwrap_or("").replace('_', "-");
 
   let quote_style = match style_string.parse::<QuoteStyle>() {
@@ -387,9 +505,9 @@ pub unsafe extern "C" fn yerba_document_set_quote_style(document: *mut Document,
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_get_collection_style(document: *const Document, path: *const c_char) -> *mut c_char {
+pub unsafe extern "C" fn yerba_document_get_collection_style(document: *const Document, selector: *const c_char) -> *mut c_char {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   match document.get_collection_style(selector_string) {
     Some(style) => CString::new(style).map(|s| s.into_raw()).unwrap_or(std::ptr::null_mut()),
@@ -398,9 +516,9 @@ pub unsafe extern "C" fn yerba_document_get_collection_style(document: *const Do
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_set_collection_style(document: *mut Document, path: *const c_char, style: *const c_char) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_set_collection_style(document: *mut Document, selector: *const c_char, style: *const c_char) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   let style_string = CStr::from_ptr(style).to_str().unwrap_or("");
 
   match document.set_collection_style(selector_string, style_string) {
@@ -410,9 +528,9 @@ pub unsafe extern "C" fn yerba_document_set_collection_style(document: *mut Docu
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_get_sequence_indent(document: *const Document, path: *const c_char) -> *mut c_char {
+pub unsafe extern "C" fn yerba_document_get_sequence_indent(document: *const Document, selector: *const c_char) -> *mut c_char {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   match document.get_sequence_indent(selector_string) {
     Some(style) => CString::new(style).map(|s| s.into_raw()).unwrap_or(std::ptr::null_mut()),
@@ -421,9 +539,9 @@ pub unsafe extern "C" fn yerba_document_get_sequence_indent(document: *const Doc
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_set_sequence_indent(document: *mut Document, path: *const c_char, style: *const c_char) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_set_sequence_indent(document: *mut Document, selector: *const c_char, style: *const c_char) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   let style_string = CStr::from_ptr(style).to_str().unwrap_or("");
 
   match document.set_sequence_indent(selector_string, style_string) {
@@ -453,32 +571,37 @@ pub unsafe extern "C" fn yerba_validate_condition(condition: *const c_char, item
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_evaluate_condition(document: *const Document, parent_path: *const c_char, condition: *const c_char) -> bool {
+pub unsafe extern "C" fn yerba_document_evaluate_condition(document: *const Document, parent_selector: *const c_char, condition: *const c_char) -> bool {
   let document = &*document;
-  let parent = CStr::from_ptr(parent_path).to_str().unwrap_or("");
+  let parent = CStr::from_ptr(parent_selector).to_str().unwrap_or("");
   let cond = CStr::from_ptr(condition).to_str().unwrap_or("");
 
   document.evaluate_condition(parent, cond).unwrap_or(false)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_exists(document: *const Document, path: *const c_char) -> bool {
+pub unsafe extern "C" fn yerba_document_exists(document: *const Document, selector: *const c_char) -> bool {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   document.exists(selector_string)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_valid_selector(document: *const Document, path: *const c_char) -> bool {
+pub unsafe extern "C" fn yerba_document_valid_selector(document: *const Document, selector: *const c_char) -> bool {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   document.is_valid_selector(selector_string)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_find(document: *const Document, path: *const c_char, condition: *const c_char, select: *const c_char) -> *mut c_char {
+pub unsafe extern "C" fn yerba_document_find(
+  document: *const Document,
+  selector: *const c_char,
+  condition: *const c_char,
+  select: *const c_char,
+) -> *mut c_char {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   let condition_string = if condition.is_null() { None } else { CStr::from_ptr(condition).to_str().ok() };
 
@@ -501,7 +624,7 @@ unsafe fn borrow_value<'a>(value: *const c_char, length: usize) -> &'a str {
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_set(
   document: *mut Document,
-  path: *const c_char,
+  selector: *const c_char,
   value: *const c_char,
   value_length: usize,
   value_type: YerbaValueType,
@@ -509,7 +632,7 @@ pub unsafe extern "C" fn yerba_document_set(
   all: bool,
 ) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   let value_string = borrow_value(value, value_length);
   let verbatim = plain || value_type != YerbaValueType::String;
 
@@ -529,7 +652,7 @@ pub unsafe extern "C" fn yerba_document_set(
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_insert(
   document: *mut Document,
-  path: *const c_char,
+  selector: *const c_char,
   value: *const c_char,
   value_length: usize,
   value_type: YerbaValueType,
@@ -540,7 +663,7 @@ pub unsafe extern "C" fn yerba_document_insert(
   at: i64,
 ) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   let raw_value = borrow_value(value, value_length);
 
   let value_string = match value_type {
@@ -557,10 +680,10 @@ pub unsafe extern "C" fn yerba_document_insert(
     InsertPosition::At(at as usize)
   } else if !before.is_null() {
     let target = CStr::from_ptr(before).to_str().unwrap_or("");
-    InsertPosition::Before(target.to_string())
+    InsertPosition::before(target)
   } else if !after.is_null() {
     let target = CStr::from_ptr(after).to_str().unwrap_or("");
-    InsertPosition::After(target.to_string())
+    InsertPosition::after(target)
   } else {
     InsertPosition::Last
   };
@@ -580,14 +703,14 @@ pub unsafe extern "C" fn yerba_document_insert(
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_insert_object(
   document: *mut Document,
-  path: *const c_char,
+  selector: *const c_char,
   json: *const c_char,
   before: *const c_char,
   after: *const c_char,
   at: i64,
 ) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   let json_string = CStr::from_ptr(json).to_str().unwrap_or("");
 
   let json_value: serde_json::Value = match serde_json::from_str(json_string) {
@@ -599,10 +722,10 @@ pub unsafe extern "C" fn yerba_document_insert_object(
     InsertPosition::At(at as usize)
   } else if !before.is_null() {
     let target = CStr::from_ptr(before).to_str().unwrap_or("");
-    InsertPosition::Before(target.to_string())
+    InsertPosition::before(target)
   } else if !after.is_null() {
     let target = CStr::from_ptr(after).to_str().unwrap_or("");
-    InsertPosition::After(target.to_string())
+    InsertPosition::after(target)
   } else {
     InsertPosition::Last
   };
@@ -614,9 +737,9 @@ pub unsafe extern "C" fn yerba_document_insert_object(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_delete(document: *mut Document, path: *const c_char) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_delete(document: *mut Document, selector: *const c_char) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   match document.delete(selector_string) {
     Ok(()) => YerbaResult::ok(),
@@ -625,9 +748,9 @@ pub unsafe extern "C" fn yerba_document_delete(document: *mut Document, path: *c
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_insert_objects(document: *mut Document, path: *const c_char, json: *const c_char) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_insert_objects(document: *mut Document, selector: *const c_char, json: *const c_char) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   let json_string = CStr::from_ptr(json).to_str().unwrap_or("");
 
   let json_values: Vec<serde_json::Value> = match serde_json::from_str(json_string) {
@@ -642,9 +765,9 @@ pub unsafe extern "C" fn yerba_document_insert_objects(document: *mut Document,
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_remove(document: *mut Document, path: *const c_char, value: *const c_char) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_remove(document: *mut Document, selector: *const c_char, value: *const c_char) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   let value_string = CStr::from_ptr(value).to_str().unwrap_or("");
 
   match document.remove(selector_string, value_string) {
@@ -654,9 +777,9 @@ pub unsafe extern "C" fn yerba_document_remove(document: *mut Document, path: *c
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_remove_at(document: *mut Document, path: *const c_char, index: usize) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_remove_at(document: *mut Document, selector: *const c_char, index: usize) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   match document.remove_at(selector_string, index) {
     Ok(()) => YerbaResult::ok(),
@@ -665,9 +788,9 @@ pub unsafe extern "C" fn yerba_document_remove_at(document: *mut Document, path:
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_move_item(document: *mut Document, path: *const c_char, from: usize, to: usize) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_move_item(document: *mut Document, selector: *const c_char, from: usize, to: usize) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   match document.move_item(selector_string, from, to) {
     Ok(()) => YerbaResult::ok(),
@@ -688,9 +811,9 @@ pub unsafe extern "C" fn yerba_document_rename(document: *mut Document, source:
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_sort(document: *mut Document, path: *const c_char, by: *const c_char, case_sensitive: bool) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_sort(document: *mut Document, selector: *const c_char, by: *const c_char, case_sensitive: bool) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   let by_string = if by.is_null() { None } else { CStr::from_ptr(by).to_str().ok() };
 
@@ -706,9 +829,9 @@ pub unsafe extern "C" fn yerba_document_sort(document: *mut Document, path: *con
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_reorder(document: *mut Document, path: *const c_char, by: *const c_char, order_csv: *const c_char) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_reorder(document: *mut Document, selector: *const c_char, by: *const c_char, order_csv: *const c_char) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   let by_string = CStr::from_ptr(by).to_str().unwrap_or("");
   let order_string = CStr::from_ptr(order_csv).to_str().unwrap_or("");
 
@@ -721,9 +844,9 @@ pub unsafe extern "C" fn yerba_document_reorder(document: *mut Document, path: *
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_sort_keys(document: *mut Document, path: *const c_char, order: *const c_char) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_sort_keys(document: *mut Document, selector: *const c_char, order: *const c_char) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   let order_string = CStr::from_ptr(order).to_str().unwrap_or("");
   let key_order: Vec<&str> = order_string.split(',').collect();
 
@@ -736,13 +859,13 @@ pub unsafe extern "C" fn yerba_document_sort_keys(document: *mut Document, path:
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_quote_style(
   document: *mut Document,
-  path: *const c_char,
+  selector: *const c_char,
   key_style: *const c_char,
   value_style: *const c_char,
 ) -> YerbaResult {
   let document = &mut *document;
 
-  let selector = if path.is_null() { None } else { CStr::from_ptr(path).to_str().ok() };
+  let selector = if selector.is_null() { None } else { CStr::from_ptr(selector).to_str().ok() };
 
   let key = if key_style.is_null() {
     None
@@ -763,9 +886,9 @@ pub unsafe extern "C" fn yerba_document_quote_style(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_blank_lines(document: *mut Document, path: *const c_char, count: usize) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_blank_lines(document: *mut Document, selector: *const c_char, count: usize) -> YerbaResult {
   let document = &mut *document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   match document.enforce_blank_lines(selector_string, count) {
     Ok(()) => YerbaResult::ok(),
@@ -784,7 +907,7 @@ pub unsafe extern "C" fn yerba_document_validate_schema(document: *const Documen
   let schema: serde_json::Value = match serde_json::from_str(schema_string) {
     Ok(schema) => schema,
     Err(e) => {
-      let error = serde_json::json!([{"message": format!("invalid schema: {}", e), "path": "", "line": null}]);
+      let error = serde_json::json!([{"message": format!("invalid schema: {}", e), "selector": "", "line": null}]);
       return CString::new(error.to_string()).unwrap_or_default().into_raw();
     }
   };
@@ -822,13 +945,13 @@ pub unsafe extern "C" fn yerba_yerbafile_find(directory: *const c_char) -> *mut
     CStr::from_ptr(directory).to_str().ok().map(std::path::PathBuf::from)
   };
 
-  let path = match start {
+  let selector = match start {
     Some(dir) => crate::Yerbafile::find_from(dir),
     None => None,
   };
 
-  match path {
-    Some(path) => CString::new(path.to_string_lossy().to_string()).unwrap_or_default().into_raw(),
+  match selector {
+    Some(selector) => CString::new(selector.to_string_lossy().to_string()).unwrap_or_default().into_raw(),
     None => ptr::null_mut(),
   }
 }
@@ -841,7 +964,7 @@ pub unsafe extern "C" fn yerba_document_apply_yerbafile(document: *mut Document,
 
   let yerbafile = if yerbafile_path.is_null() {
     match crate::Yerbafile::find() {
-      Some(path) => match crate::Yerbafile::load(&path) {
+      Some(selector) => match crate::Yerbafile::load(&selector) {
         Ok(yerbafile) => yerbafile,
         Err(e) => return YerbaResult::err(&e.to_string()),
       },
@@ -849,9 +972,9 @@ pub unsafe extern "C" fn yerba_document_apply_yerbafile(document: *mut Document,
       None => return YerbaResult::err("No Yerbafile found"),
     }
   } else {
-    let path = CStr::from_ptr(yerbafile_path).to_str().unwrap_or("");
+    let selector = CStr::from_ptr(yerbafile_path).to_str().unwrap_or("");
 
-    match crate::Yerbafile::load(path) {
+    match crate::Yerbafile::load(selector) {
       Ok(yerbafile) => yerbafile,
       Err(e) => return YerbaResult::err(&e.to_string()),
     }
@@ -900,6 +1023,62 @@ pub unsafe extern "C" fn yerba_result_free(result: YerbaResult) {
   }
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_nodes(document: *const Document) -> YerbaNodeList {
+  let document = &*document;
+
+  let records: Vec<YerbaNodeRecord> = document
+    .node_records()
+    .into_iter()
+    .map(|record| YerbaNodeRecord {
+      parent: record.parent.map(|parent| parent as isize).unwrap_or(-1),
+      node_type: record.node_type,
+      selector: CString::new(record.selector).unwrap_or_default().into_raw(),
+      key_name: record
+        .key_name
+        .map(|name| CString::new(name).unwrap_or_default().into_raw())
+        .unwrap_or(ptr::null_mut()),
+      value: match record.scalar {
+        Some(scalar) => YerbaTypedValue::new(&scalar.text, detect_yaml_type(&scalar)),
+        None => YerbaTypedValue {
+          text: ptr::null_mut(),
+          value_type: YerbaValueType::Null,
+        },
+      },
+      has_value: record.has_value,
+      location: location_to_ffi(record.location),
+      key_location: location_to_ffi(record.key_location),
+    })
+    .collect();
+
+  let mut records = records.into_boxed_slice();
+  let list = YerbaNodeList {
+    records: records.as_mut_ptr(),
+    length: records.len(),
+  };
+
+  std::mem::forget(records);
+
+  list
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn yerba_node_list_free(list: YerbaNodeList) {
+  if list.records.is_null() {
+    return;
+  }
+
+  let records = Box::from_raw(std::ptr::slice_from_raw_parts_mut(list.records, list.length));
+
+  for record in records.iter() {
+    for pointer in [record.selector, record.key_name, record.value.text] {
+      if !pointer.is_null() {
+        drop(CString::from_raw(pointer));
+      }
+    }
+  }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_get_result_free(result: YerbaGetResult) {
   if !result.single.text.is_null() {
@@ -923,14 +1102,7 @@ fn located_nodes_to_list(nodes: &[crate::LocatedNode]) -> YerbaTypedList {
         "node_type": node.node_type,
         "selector": node.selector,
         "line": node.line,
-        "location": {
-          "start_line": node.location.start_line,
-          "start_column": node.location.start_column,
-          "end_line": node.location.end_line,
-          "end_column": node.location.end_column,
-          "start_offset": node.location.start_offset,
-          "end_offset": node.location.end_offset,
-        },
+        "location": location_json(&node.location),
       });
 
       if let Some(file_path) = &node.file_path {
@@ -938,7 +1110,7 @@ fn located_nodes_to_list(nodes: &[crate::LocatedNode]) -> YerbaTypedList {
       }
 
       if let Some(text) = &node.text {
-        value["text"] = serde_json::json!(text);
+        value["text"] = serde_json::json!(typed_text(text, node.value_type.unwrap_or(YerbaValueType::String)));
       }
 
       if let Some(vt) = node.value_type {
@@ -947,14 +1119,7 @@ fn located_nodes_to_list(nodes: &[crate::LocatedNode]) -> YerbaTypedList {
 
       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["key_location"] = location_json(&node.key_location);
       }
 
       value
@@ -972,26 +1137,31 @@ fn located_nodes_to_list(nodes: &[crate::LocatedNode]) -> YerbaTypedList {
 
 #[cfg(feature = "glob")]
 #[no_mangle]
-pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *const c_char) -> YerbaTypedList {
+pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, selector: *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 selector_string = CStr::from_ptr(selector).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 {
+pub unsafe extern "C" fn yerba_document_get_all(document: *const Document, selector: *const c_char) -> YerbaTypedList {
   let document = &*document;
-  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
   located_nodes_to_list(&document.get_all_located(selector_string))
 }
 
 #[cfg(feature = "glob")]
 #[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 {
+pub unsafe extern "C" fn yerba_glob_find(
+  glob_pattern: *const c_char,
+  selector: *const c_char,
+  condition: *const c_char,
+  select: *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 selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
   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() };