yerba 0.2.2-aarch64-linux-gnu → 0.4.0-aarch64-linux-gnu

data/rust/src/ffi.rs

@@ -12,10 +12,8 @@ use std::ffi::{CStr, CString};
 use std::os::raw::c_char;
 use std::ptr;
 
-use yaml_parser::SyntaxKind;
-
-use crate::selector::Selector;
 use crate::syntax::{detect_yaml_type, YerbaValueType};
+use crate::NodeType;
 use crate::{Document, InsertPosition, QuoteStyle};
 
 #[repr(C)]
@@ -52,15 +50,6 @@ pub struct YerbaTypedList {
   pub length: usize,
 }
 
-#[repr(C)]
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum YerbaNodeType {
-  Scalar = 0,
-  Map = 1,
-  Sequence = 2,
-  NotFound = 3,
-}
-
 #[repr(C)]
 pub struct YerbaParseResult {
   pub document: *mut Document,
@@ -80,7 +69,7 @@ pub struct YerbaLocation {
 #[repr(C)]
 pub struct YerbaGetResult {
   pub is_list: bool,
-  pub node_type: YerbaNodeType,
+  pub node_type: NodeType,
   pub single: YerbaTypedValue,
   pub list: YerbaTypedList,
   pub location: YerbaLocation,
@@ -89,6 +78,72 @@ pub struct YerbaGetResult {
   pub error: *mut c_char,
 }
 
+impl YerbaGetResult {
+  fn empty() -> Self {
+    YerbaGetResult {
+      is_list: false,
+      node_type: NodeType::NotFound,
+      single: YerbaTypedValue {
+        text: ptr::null_mut(),
+        value_type: YerbaValueType::Null,
+      },
+      list: YerbaTypedList {
+        json: ptr::null_mut(),
+        length: 0,
+      },
+      location: EMPTY_LOCATION,
+      key_name: ptr::null_mut(),
+      key_location: EMPTY_LOCATION,
+      error: ptr::null_mut(),
+    }
+  }
+
+  fn with_error(error: &str) -> Self {
+    let mut result = Self::empty();
+
+    result.error = CString::new(error).unwrap_or_default().into_raw();
+
+    result
+  }
+
+  fn with_location(mut self, location: YerbaLocation, key_name: *mut c_char, key_location: YerbaLocation) -> Self {
+    self.location = location;
+    self.key_name = key_name;
+    self.key_location = key_location;
+
+    self
+  }
+
+  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
+  }
+
+  fn list(mut self, json: &str, length: usize) -> Self {
+    self.is_list = true;
+    self.node_type = NodeType::Sequence;
+
+    self.list = YerbaTypedList {
+      json: CString::new(json).unwrap_or_default().into_raw(),
+      length,
+    };
+
+    self
+  }
+
+  fn with_node_type(mut self, node_type: NodeType) -> Self {
+    self.node_type = node_type;
+
+    self
+  }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_parse_file(path: *const c_char) -> YerbaParseResult {
   if path.is_null() {
@@ -98,19 +153,17 @@ pub unsafe extern "C" fn yerba_document_parse_file(path: *const c_char) -> Yerba
     };
   }
 
-  let path_string = match CStr::from_ptr(path).to_str() {
+  let file_path = match CStr::from_ptr(path).to_str() {
     Ok(string) => string,
     Err(e) => {
       return YerbaParseResult {
         document: ptr::null_mut(),
-        error: CString::new(format!("Invalid UTF-8 in path: {}", e))
-          .unwrap_or_default()
-          .into_raw(),
+        error: CString::new(format!("Invalid UTF-8 in path: {}", e)).unwrap_or_default().into_raw(),
       }
     }
   };
 
-  match Document::parse_file(path_string) {
+  match Document::parse_file(file_path) {
     Ok(document) => YerbaParseResult {
       document: Box::into_raw(Box::new(document)),
       error: ptr::null_mut(),
@@ -137,9 +190,7 @@ pub unsafe extern "C" fn yerba_document_parse(content: *const c_char) -> YerbaPa
     Err(e) => {
       return YerbaParseResult {
         document: ptr::null_mut(),
-        error: CString::new(format!("Invalid UTF-8: {}", e))
-          .unwrap_or_default()
-          .into_raw(),
+        error: CString::new(format!("Invalid UTF-8: {}", e)).unwrap_or_default().into_raw(),
       }
     }
   };
@@ -157,28 +208,6 @@ pub unsafe extern "C" fn yerba_document_parse(content: *const c_char) -> YerbaPa
   }
 }
 
-fn compute_location(source: &str, start_offset: usize, end_offset: usize) -> YerbaLocation {
-  let start = start_offset.min(source.len());
-  let end = end_offset.min(source.len());
-
-  let before_start = &source[..start];
-  let start_line = before_start.chars().filter(|c| *c == '\n').count() + 1;
-  let start_column = start - before_start.rfind('\n').map(|p| p + 1).unwrap_or(0);
-
-  let before_end = &source[..end];
-  let end_line = before_end.chars().filter(|c| *c == '\n').count() + 1;
-  let end_column = end - before_end.rfind('\n').map(|p| p + 1).unwrap_or(0);
-
-  YerbaLocation {
-    start_offset: start,
-    end_offset: end,
-    start_line,
-    start_column,
-    end_line,
-    end_column,
-  }
-}
-
 const EMPTY_LOCATION: YerbaLocation = YerbaLocation {
   start_offset: 0,
   end_offset: 0,
@@ -198,173 +227,71 @@ 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 {
   let document = &*document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
-
-  let selector = Selector::parse(path_string);
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
 
-  if let Err(e) = Document::validate_path(path_string) {
-    return YerbaGetResult {
-      is_list: false,
-      node_type: YerbaNodeType::NotFound,
-      single: YerbaTypedValue {
-        text: ptr::null_mut(),
-        value_type: YerbaValueType::Null,
-      },
-      list: YerbaTypedList {
-        json: ptr::null_mut(),
-        length: 0,
-      },
-      key_name: ptr::null_mut(),
-      key_location: EMPTY_LOCATION,
-      location: EMPTY_LOCATION,
-      error: CString::new(e.to_string()).unwrap_or_default().into_raw(),
-    };
+  if let Err(e) = Document::validate_path(selector_string) {
+    return YerbaGetResult::with_error(&e.to_string());
   }
 
-  let source = document.to_string();
-
-  let (location, key_text, key_location) = match document.navigate(path_string) {
-    Ok(node) => {
-      let range = node.text_range();
-      let location = compute_location(&source, range.start().into(), range.end().into());
-
-      let (key_text, key_location) = node
-        .parent()
-        .and_then(|parent| {
-          use rowan::ast::AstNode;
-          use yaml_parser::ast::BlockMapEntry;
+  let info = document.get_node_info(selector_string);
+  let location = location_to_ffi(info.location);
+  let key_location = location_to_ffi(info.key_location);
 
-          BlockMapEntry::cast(parent).and_then(|entry| {
-            entry.key().and_then(|key_node| {
-              let key_text = crate::syntax::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, EMPTY_LOCATION));
-
-      (location, key_text, key_location)
-    }
-    Err(_) => (EMPTY_LOCATION, None, EMPTY_LOCATION),
-  };
-
-  let key_name_pointer = key_text
+  let key_name = info
+    .key_name
     .map(|name| CString::new(name).unwrap_or_default().into_raw())
     .unwrap_or(ptr::null_mut());
 
-  if selector.has_wildcard() {
-    let values = document.get_all_typed(path_string);
+  let base = YerbaGetResult::empty().with_location(location, key_name, key_location);
 
-    let typed: Vec<serde_json::Value> = values
+  if info.is_list {
+    let typed: Vec<serde_json::Value> = info
+      .list_values
       .iter()
-      .map(|serde_value| {
+      .map(|value| {
         serde_json::json!({
-          "text": serde_value.text,
-          "type": detect_yaml_type(serde_value) as u8
+          "text": value.text,
+          "type": detect_yaml_type(value) as u8
         })
       })
       .collect();
 
     let json = serde_json::to_string(&typed).unwrap_or_else(|_| "[]".to_string());
-    let length = values.len();
 
-    YerbaGetResult {
-      is_list: true,
-      node_type: YerbaNodeType::Sequence,
-      single: YerbaTypedValue {
-        text: ptr::null_mut(),
-        value_type: YerbaValueType::Null,
-      },
-      list: YerbaTypedList {
-        json: CString::new(json).unwrap_or_default().into_raw(),
-        length,
-      },
-      location,
-      key_name: key_name_pointer,
-      key_location,
-      error: ptr::null_mut(),
-    }
+    base.list(&json, info.list_values.len())
   } else {
-    match document.get_typed(path_string) {
-      Some(scalar) => {
-        let vtype = detect_yaml_type(&scalar);
-
-        YerbaGetResult {
-          is_list: false,
-          node_type: YerbaNodeType::Scalar,
-          single: YerbaTypedValue {
-            text: CString::new(scalar.text).unwrap_or_default().into_raw(),
-            value_type: vtype,
-          },
-          list: YerbaTypedList {
-            json: ptr::null_mut(),
-            length: 0,
-          },
-          location,
-          key_name: key_name_pointer,
-          key_location,
-          error: ptr::null_mut(),
-        }
-      }
-
-      None => {
-        use rowan::ast::AstNode;
-        use yaml_parser::ast::{BlockMap, BlockSeq};
-
-        let node_type = match document.navigate(path_string) {
-          Ok(node) => {
-            if node.children().any(|child| BlockSeq::can_cast(child.kind())) {
-              YerbaNodeType::Sequence
-            } else if node.children().any(|child| BlockMap::can_cast(child.kind())) {
-              YerbaNodeType::Map
-            } else if node.descendants().any(|child| BlockSeq::can_cast(child.kind())) {
-              YerbaNodeType::Sequence
-            } else if node.descendants().any(|child| BlockMap::can_cast(child.kind())) {
-              YerbaNodeType::Map
-            } else {
-              YerbaNodeType::NotFound
-            }
-          }
-          Err(_) => YerbaNodeType::NotFound,
-        };
-
-        YerbaGetResult {
-          is_list: false,
-          node_type,
-          single: YerbaTypedValue {
-            text: ptr::null_mut(),
-            value_type: YerbaValueType::Null,
-          },
-          list: YerbaTypedList {
-            json: ptr::null_mut(),
-            length: 0,
-          },
-          location,
-          key_name: key_name_pointer,
-          key_location,
-          error: ptr::null_mut(),
-        }
-      }
+    match info.value {
+      Some(scalar) => base.scalar(&scalar.text, detect_yaml_type(&scalar)),
+      None => base.with_node_type(info.node_type),
     }
   }
 }
 
+fn location_to_ffi(location: crate::Location) -> YerbaLocation {
+  YerbaLocation {
+    start_offset: location.start_offset,
+    end_offset: location.end_offset,
+    start_line: location.start_line,
+    start_column: location.start_column,
+    end_line: location.end_line,
+    end_column: location.end_column,
+  }
+}
+
 /// 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 {
   let document = &*document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
 
-  match document.get_value(path_string) {
+  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());
+
       CString::new(json_string).unwrap_or_default().into_raw()
     }
+
     None => ptr::null_mut(),
   }
 }
@@ -373,9 +300,9 @@ pub unsafe extern "C" fn yerba_document_get_value(document: *const Document, pat
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_get_values(document: *const Document, path: *const c_char) -> *mut c_char {
   let document = &*document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
 
-  let values = document.get_values(path_string);
+  let values = document.get_values(selector_string);
   let json_values: Vec<serde_json::Value> = values.iter().map(crate::json::yaml_to_json).collect();
   let json_string = serde_json::to_string(&json_values).unwrap_or_else(|_| "[]".to_string());
 
@@ -383,50 +310,40 @@ pub unsafe extern "C" fn yerba_document_get_values(document: *const Document, pa
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_get_quote_style(document: *const Document, path: *const c_char) -> i32 {
+pub unsafe extern "C" fn yerba_document_get_quote_style(document: *const Document, path: *const c_char) -> *mut c_char {
   let document = &*document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
-
-  match document.get_typed(path_string) {
-    Some(scalar) => match scalar.kind {
-      SyntaxKind::PLAIN_SCALAR => 0,
-      SyntaxKind::SINGLE_QUOTED_SCALAR => 1,
-      SyntaxKind::DOUBLE_QUOTED_SCALAR => 2,
-      _ => -1,
-    },
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+
+  match document.get_quote_style(selector_string) {
+    Some(style) => {
+      let ruby_style = style.replace('-', "_");
 
-    None => -1,
+      CString::new(ruby_style).map(|s| s.into_raw()).unwrap_or(std::ptr::null_mut())
+    }
+
+    None => std::ptr::null_mut(),
   }
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_set_quote_style(
-  document: *mut Document,
-  path: *const c_char,
-  style: i32,
-) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_set_quote_style(document: *mut Document, path: *const c_char, style: *const c_char) -> YerbaResult {
   let document = &mut *document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let style_string = &CStr::from_ptr(style).to_str().unwrap_or("").replace('_', "-");
 
-  let quote_style = match style {
-    0 => QuoteStyle::Plain,
-    1 => QuoteStyle::Single,
-    2 => QuoteStyle::Double,
-    _ => return YerbaResult::err("Invalid quote style (use 0=plain, 1=single, 2=double)"),
+  let quote_style = match style_string.parse::<QuoteStyle>() {
+    Ok(style) => style,
+    Err(e) => return YerbaResult::err(&e),
   };
 
-  match document.set_scalar_style(path_string, &quote_style) {
-    Ok(()) => YerbaResult::ok(),
+  match document.enforce_quotes_at(&quote_style, Some(selector_string)) {
+    Ok(_warnings) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }
 }
 
 #[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_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("");
@@ -436,62 +353,22 @@ pub unsafe extern "C" fn yerba_document_evaluate_condition(
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_exists(document: *const Document, path: *const c_char) -> bool {
   let document = &*document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
-  document.exists(path_string)
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  document.exists(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, path: *const c_char, condition: *const c_char, select: *const c_char) -> *mut c_char {
   let document = &*document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
-
-  let condition_str = 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 values = match condition_str {
-    Some(cond) => document.filter(path_string, cond),
-    None => document.get_values(path_string),
-  };
-
-  let select_fields: Option<Vec<&str>> = _select_string.map(|s| s.split(',').collect());
-
-  let mut results: Vec<serde_json::Value> = Vec::new();
-
-  for value in &values {
-    match &select_fields {
-      Some(fields) => {
-        let mut result = serde_json::Map::new();
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
 
-        for field in fields {
-          let json_value = crate::json::resolve_select_field(value, field);
-          let json_key = crate::json::select_field_key(field);
+  let condition_string = if condition.is_null() { None } else { CStr::from_ptr(condition).to_str().ok() };
 
-          result.insert(json_key, json_value);
-        }
-
-        results.push(serde_json::Value::Object(result));
-      }
-      None => {
-        results.push(crate::json::yaml_to_json(value));
-      }
-    }
-  }
+  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 json = serde_json::to_string_pretty(&results).unwrap_or_else(|_| "[]".to_string());
+
   CString::new(json).unwrap_or_default().into_raw()
 }
 
@@ -501,14 +378,19 @@ pub unsafe extern "C" fn yerba_document_set(
   path: *const c_char,
   value: *const c_char,
   value_type: YerbaValueType,
+  all: bool,
 ) -> YerbaResult {
   let document = &mut *document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
   let value_string = CStr::from_ptr(value).to_str().unwrap_or("");
 
-  let result = match value_type {
-    YerbaValueType::String => document.set(path_string, value_string),
-    _ => document.set_plain(path_string, value_string),
+  let result = if all {
+    document.set_all(selector_string, value_string)
+  } else {
+    match value_type {
+      YerbaValueType::String => document.set(selector_string, value_string),
+      _ => document.set_plain(selector_string, value_string),
+    }
   };
 
   match result {
@@ -527,7 +409,7 @@ pub unsafe extern "C" fn yerba_document_insert(
   at: i64,
 ) -> YerbaResult {
   let document = &mut *document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
   let value_string = CStr::from_ptr(value).to_str().unwrap_or("");
 
   let position = if at >= 0 {
@@ -542,7 +424,7 @@ pub unsafe extern "C" fn yerba_document_insert(
     InsertPosition::Last
   };
 
-  match document.insert_into(path_string, value_string, position) {
+  match document.insert_into(selector_string, value_string, position) {
     Ok(()) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }
@@ -558,60 +440,14 @@ pub unsafe extern "C" fn yerba_document_insert_object(
   at: i64,
 ) -> YerbaResult {
   let document = &mut *document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).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) {
-    Ok(v) => v,
+    Ok(value) => value,
     Err(e) => return YerbaResult::err(&format!("Invalid JSON: {}", e)),
   };
 
-  let try_paths = if path_string.is_empty() {
-    vec!["[]".to_string(), "[0]".to_string()]
-  } else {
-    vec![format!("{}[]", path_string), format!("{}[0]", path_string)]
-  };
-
-  let mut quote_style = QuoteStyle::Plain;
-
-  'outer: for try_path in &try_paths {
-    for scalar in document.get_all_typed(try_path) {
-      if scalar.kind == SyntaxKind::DOUBLE_QUOTED_SCALAR {
-        quote_style = QuoteStyle::Double;
-        break 'outer;
-      } else if scalar.kind == SyntaxKind::SINGLE_QUOTED_SCALAR {
-        quote_style = QuoteStyle::Single;
-        break 'outer;
-      }
-    }
-  }
-
-  if quote_style == QuoteStyle::Plain {
-    if let Some(serde_yaml::Value::Sequence(seq)) = document.get_value(path_string).as_ref() {
-      if let Some(serde_yaml::Value::Mapping(map)) = seq.first() {
-        if let Some((serde_yaml::Value::String(key_name), _)) = map.iter().next() {
-          let deep_path = if path_string.is_empty() {
-            format!("[].{}", key_name)
-          } else {
-            format!("{}[].{}", path_string, key_name)
-          };
-
-          for scalar in document.get_all_typed(&deep_path) {
-            if scalar.kind == SyntaxKind::DOUBLE_QUOTED_SCALAR {
-              quote_style = QuoteStyle::Double;
-              break;
-            } else if scalar.kind == SyntaxKind::SINGLE_QUOTED_SCALAR {
-              quote_style = QuoteStyle::Single;
-              break;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  let yaml_text = crate::yaml_writer::json_to_yaml_text(&json_value, &quote_style, 0);
-
   let position = if at >= 0 {
     InsertPosition::At(at as usize)
   } else if !before.is_null() {
@@ -624,7 +460,7 @@ pub unsafe extern "C" fn yerba_document_insert_object(
     InsertPosition::Last
   };
 
-  match document.insert_into(path_string, &yaml_text, position) {
+  match document.insert_object(selector_string, &json_value, position) {
     Ok(()) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }
@@ -633,51 +469,50 @@ 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 {
   let document = &mut *document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
 
-  match document.delete(path_string) {
+  match document.delete(selector_string) {
     Ok(()) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }
 }
 
 #[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, path: *const c_char, value: *const c_char) -> YerbaResult {
   let document = &mut *document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
   let value_string = CStr::from_ptr(value).to_str().unwrap_or("");
 
-  match document.remove(path_string, value_string) {
+  match document.remove(selector_string, value_string) {
     Ok(()) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }
 }
 
 #[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, path: *const c_char, index: usize) -> YerbaResult {
   let document = &mut *document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
 
-  match document.remove_at(path_string, index) {
+  match document.remove_at(selector_string, index) {
     Ok(()) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_rename(
-  document: *mut Document,
-  source: *const c_char,
-  dest: *const c_char,
-) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_move_item(document: *mut Document, path: *const c_char, from: usize, to: usize) -> YerbaResult {
+  let document = &mut *document;
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+
+  match document.move_item(selector_string, from, to) {
+    Ok(()) => YerbaResult::ok(),
+    Err(e) => YerbaResult::err(&e.to_string()),
+  }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_rename(document: *mut Document, source: *const c_char, dest: *const c_char) -> YerbaResult {
   let document = &mut *document;
   let source_string = CStr::from_ptr(source).to_str().unwrap_or("");
   let dest_string = CStr::from_ptr(dest).to_str().unwrap_or("");
@@ -689,59 +524,46 @@ pub unsafe extern "C" fn yerba_document_rename(
 }
 
 #[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, path: *const c_char, by: *const c_char, case_sensitive: bool) -> YerbaResult {
   let document = &mut *document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
 
-  let by_string = if by.is_null() {
-    None
-  } else {
-    CStr::from_ptr(by).to_str().ok()
-  };
+  let by_string = if by.is_null() { None } else { CStr::from_ptr(by).to_str().ok() };
 
   let sort_fields: Vec<crate::SortField> = match by_string {
-    Some(fields) => fields
-      .split(',')
-      .map(|field| {
-        if let Some(name) = field.strip_suffix(":desc") {
-          crate::SortField {
-            path: name.to_string(),
-            ascending: false,
-          }
-        } else {
-          crate::SortField {
-            path: field.to_string(),
-            ascending: true,
-          }
-        }
-      })
-      .collect(),
+    Some(fields) => crate::SortField::parse_list(fields),
     None => vec![],
   };
 
-  match document.sort_items(path_string, &sort_fields, case_sensitive) {
+  match document.sort_items(selector_string, &sort_fields, case_sensitive) {
     Ok(()) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }
 }
 
 #[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_reorder(document: *mut Document, path: *const c_char, by: *const c_char, order_csv: *const c_char) -> YerbaResult {
   let document = &mut *document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).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("");
+
+  let desired_order: Vec<&str> = order_string.split(',').map(|s| s.trim()).collect();
+
+  match document.reorder_items(selector_string, by_string, &desired_order) {
+    Ok(()) => YerbaResult::ok(),
+    Err(e) => YerbaResult::err(&e.to_string()),
+  }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_sort_keys(document: *mut Document, path: *const c_char, order: *const c_char) -> YerbaResult {
+  let document = &mut *document;
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
   let order_string = CStr::from_ptr(order).to_str().unwrap_or("");
   let key_order: Vec<&str> = order_string.split(',').collect();
 
-  match document.sort_keys(path_string, &key_order) {
+  match document.sort_keys(selector_string, &key_order) {
     Ok(()) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }
@@ -756,55 +578,32 @@ pub unsafe extern "C" fn yerba_document_quote_style(
 ) -> YerbaResult {
   let document = &mut *document;
 
-  let path_string = if path.is_null() {
-    None
-  } else {
-    CStr::from_ptr(path).to_str().ok()
-  };
+  let selector = if path.is_null() { None } else { CStr::from_ptr(path).to_str().ok() };
 
-  let key_quote_style = if key_style.is_null() {
+  let key = if key_style.is_null() {
     None
   } else {
-    CStr::from_ptr(key_style)
-      .to_str()
-      .ok()
-      .and_then(|s| s.parse::<QuoteStyle>().ok())
+    CStr::from_ptr(key_style).to_str().ok().and_then(|s| s.parse::<crate::KeyStyle>().ok())
   };
 
-  let value_quote_style = if value_style.is_null() {
+  let value = if value_style.is_null() {
     None
   } else {
-    CStr::from_ptr(value_style)
-      .to_str()
-      .ok()
-      .and_then(|s| s.parse::<QuoteStyle>().ok())
+    CStr::from_ptr(value_style).to_str().ok().and_then(|s| s.parse::<QuoteStyle>().ok())
   };
 
-  if let Some(ref key_style) = key_quote_style {
-    if let Err(e) = document.enforce_key_style(key_style, path_string) {
-      return YerbaResult::err(&e.to_string());
-    }
-  }
-
-  if let Some(ref value_style) = value_quote_style {
-    if let Err(e) = document.enforce_quotes_at(value_style, path_string) {
-      return YerbaResult::err(&e.to_string());
-    }
+  match document.enforce_quote_style(key.as_ref(), value.as_ref(), selector) {
+    Ok(()) => YerbaResult::ok(),
+    Err(e) => YerbaResult::err(&e.to_string()),
   }
-
-  YerbaResult::ok()
 }
 
 #[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, path: *const c_char, count: usize) -> YerbaResult {
   let document = &mut *document;
-  let path_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
 
-  match document.enforce_blank_lines(path_string, count) {
+  match document.enforce_blank_lines(selector_string, count) {
     Ok(()) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }
@@ -850,42 +649,12 @@ 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 path_string = CStr::from_ptr(path).to_str().unwrap_or("");
-  let selector = Selector::parse(path_string);
-
-  let files = match glob::glob(pattern) {
-    Ok(paths) => paths.filter_map(|p| p.ok()).collect::<Vec<_>>(),
-    Err(_) => {
-      return YerbaTypedList {
-        json: CString::new("[]").unwrap_or_default().into_raw(),
-        length: 0,
-      }
-    }
-  };
-
-  use rayon::prelude::*;
-
-  let results: Vec<serde_json::Value> = files
-    .par_iter()
-    .flat_map(|file| {
-      let mut file_results = Vec::new();
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let scalars = crate::glob_get(pattern, selector_string);
 
-      if let Ok(document) = Document::parse_file(file) {
-        if selector.has_wildcard() {
-          for scalar in document.get_all_typed(path_string) {
-            let value_type = detect_yaml_type(&scalar);
-
-            file_results.push(serde_json::json!({"text": scalar.text, "type": value_type as u8}));
-          }
-        } else if let Some(scalar) = document.get_typed(path_string) {
-          let value_type = detect_yaml_type(&scalar);
-
-          file_results.push(serde_json::json!({"text": scalar.text, "type": value_type as u8}));
-        }
-      }
-
-      file_results
-    })
+  let results: Vec<serde_json::Value> = scalars
+    .iter()
+    .map(|scalar| serde_json::json!({"text": scalar.text, "type": detect_yaml_type(scalar) as u8}))
     .collect();
 
   let length = results.len();
@@ -898,89 +667,13 @@ pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *cons
 }
 
 #[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, path: *const c_char, condition: *const c_char, select: *const c_char) -> YerbaTypedList {
   let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");
-  let path_string = CStr::from_ptr(path).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()
-  };
-
-  let files = match glob::glob(pattern) {
-    Ok(paths) => paths.filter_map(|p| p.ok()).collect::<Vec<_>>(),
-    Err(_) => {
-      return YerbaTypedList {
-        json: CString::new("[]").unwrap_or_default().into_raw(),
-        length: 0,
-      }
-    }
-  };
-
-  use rayon::prelude::*;
-
-  let select_fields: Option<Vec<&str>> = _select_string.map(|s| s.split(',').collect());
-
-  let all_results: Vec<serde_json::Value> = files
-    .par_iter()
-    .flat_map(|file| {
-      let mut file_results = Vec::new();
-
-      if let Ok(document) = Document::parse_file(file) {
-        let values = match condition_string {
-          Some(cond) => document.filter(path_string, cond),
-          None => document.get_values(path_string),
-        };
-
-        let file_string = file.to_string_lossy().to_string();
-
-        for value in &values {
-          let mut result = serde_json::Map::new();
-          result.insert("__file".to_string(), serde_json::Value::String(file_string.clone()));
-
-          match &select_fields {
-            Some(fields) => {
-              for field in fields {
-                let json_value = crate::json::resolve_select_field(value, field);
-                let json_key = crate::json::select_field_key(field);
-                result.insert(json_key, json_value);
-              }
-            }
-
-            None => {
-              if let serde_yaml::Value::Mapping(map) = value {
-                for (key, yaml_value) in map {
-                  let json_key = match key {
-                    serde_yaml::Value::String(string) => string.clone(),
-                    _ => format!("{:?}", key),
-                  };
-
-                  result.insert(json_key, crate::json::yaml_to_json(yaml_value));
-                }
-              }
-            }
-          }
-
-          file_results.push(serde_json::Value::Object(result));
-        }
-      }
-
-      file_results
-    })
-    .collect();
+  let selector_string = CStr::from_ptr(path).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() };
 
+  let all_results = crate::glob_find(pattern, selector_string, condition_string, select_string);
   let length = all_results.len();
   let json = serde_json::to_string_pretty(&all_results).unwrap_or_else(|_| "[]".to_string());