yerba 0.8.0-arm-linux-gnu → 0.9.0-arm-linux-gnu

data/rust/src/document/set.rs

@@ -1,5 +1,23 @@
 use super::*;
 
+fn is_plain_writable(value: &str) -> bool {
+  crate::syntax::is_plain_safe(value) && !crate::syntax::is_yaml_non_string(value)
+}
+
+fn scalar_replacement_text(value: &str, kind: SyntaxKind) -> String {
+  let representable = match kind {
+    SyntaxKind::PLAIN_SCALAR => is_plain_writable(value),
+    SyntaxKind::SINGLE_QUOTED_SCALAR => crate::syntax::is_single_quotable(value),
+    _ => true,
+  };
+
+  if !representable {
+    return format_scalar_value(value, SyntaxKind::DOUBLE_QUOTED_SCALAR);
+  }
+
+  format_scalar_value(value, kind)
+}
+
 fn holds_collection(node: &SyntaxNode) -> bool {
   node.descendants().any(|descendant| {
     matches!(
@@ -54,6 +72,34 @@ fn value_span(node: &SyntaxNode) -> Option<ValueSpan> {
   })
 }
 
+fn scalar_edit(source: &str, node: &SyntaxNode, value: &str, plain: bool) -> Option<(TextRange, String)> {
+  if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
+    let replacement = if plain {
+      value.to_string()
+    } else {
+      Document::block_scalar_replacement(source, &block_scalar, value)
+    };
+
+    return Some((block_scalar.text_range(), replacement));
+  }
+
+  if holds_collection(node) {
+    let replacement = if plain { value.to_string() } else { crate::syntax::quote_scalar(value) };
+
+    return value_span(node).map(|span| (span.range, replacement_text(&span, &replacement)));
+  }
+
+  let scalar_token = find_scalar_token(node)?;
+
+  let replacement = if plain {
+    value.to_string()
+  } else {
+    scalar_replacement_text(value, scalar_token.kind())
+  };
+
+  Some((scalar_token.text_range(), replacement))
+}
+
 fn replacement_text(span: &ValueSpan, value: &str) -> String {
   let mut text = if span.separated { format!(" {}", value) } else { value.to_string() };
 
@@ -67,51 +113,70 @@ fn replacement_text(span: &ValueSpan, value: &str) -> String {
 
 impl Document {
   pub fn set(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
-    let current_node = self.navigate(dot_path)?;
+    self.set_with(dot_path, value, false)
+  }
 
-    if let Some(block_scalar) = current_node.descendants().find(|node| node.kind() == SyntaxKind::BLOCK_SCALAR) {
-      let source = self.source_text();
-      let new_text = Self::block_scalar_replacement(&source, &block_scalar, value);
+  pub fn set_all(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
+    self.set_all_with(dot_path, value, false)
+  }
 
-      return self.apply_edit(block_scalar.text_range(), &new_text);
-    }
+  pub fn set_all_plain(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
+    self.set_all_with(dot_path, value, true)
+  }
 
-    if holds_collection(&current_node) {
-      let span = value_span(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+  fn set_all_with(&mut self, dot_path: &str, value: &str, plain: bool) -> Result<(), YerbaError> {
+    let nodes = self.navigate_all_compact(dot_path);
 
-      return self.apply_edit(span.range, &replacement_text(&span, value));
+    if nodes.is_empty() {
+      return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
     }
 
-    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());
+    let source = self.source_text();
+    let edits = nodes.iter().filter_map(|node| scalar_edit(&source, node, value, plain)).collect();
 
-    self.replace_token(&scalar_token, &new_text)
+    self.apply_edits(edits)
   }
 
-  pub fn set_all(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
-    let nodes = self.navigate_all_compact(dot_path);
+  pub fn set_where(&mut self, container_path: &str, relative_path: &str, value: &str, condition: &str, all: bool, plain: bool) -> Result<usize, YerbaError> {
+    validate_item_condition(condition)?;
 
-    if nodes.is_empty() {
-      return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
+    let items = self.navigate_all_compact(container_path);
+
+    if items.is_empty() {
+      return Err(YerbaError::SelectorNotFound(container_path.to_string()));
     }
 
     let source = self.source_text();
-    let mut edits: Vec<(TextRange, String)> = Vec::new();
-
-    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())));
+    let mut targets: Vec<SyntaxNode> = Vec::new();
+
+    for item in &items {
+      if !self.evaluate_condition_on_node(item, condition) {
+        continue;
       }
+
+      targets.extend(navigate_from_node(item, relative_path));
     }
 
-    self.apply_edits(edits)
+    if targets.is_empty() {
+      return Ok(0);
+    }
+
+    if !all && targets.len() > 1 {
+      let selector = if container_path.is_empty() {
+        relative_path.to_string()
+      } else {
+        format!("{}.{}", container_path, relative_path)
+      };
+
+      return Err(YerbaError::AmbiguousSelector(selector, targets.len()));
+    }
+
+    let edits: Vec<(TextRange, String)> = targets.iter().filter_map(|node| scalar_edit(&source, node, value, plain)).collect();
+    let count = edits.len();
+
+    self.apply_edits(edits)?;
+
+    Ok(count)
   }
 
   pub fn set_scalar_style(&mut self, dot_path: &str, style: &QuoteStyle) -> Result<(), YerbaError> {
@@ -136,22 +201,39 @@ impl Document {
   }
 
   pub fn set_plain(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
+    self.set_with(dot_path, value, true)
+  }
+
+  fn set_with(&mut self, dot_path: &str, value: &str, plain: bool) -> Result<(), YerbaError> {
     let current_node = self.navigate(dot_path)?;
 
     if let Some(block_scalar) = current_node.descendants().find(|node| node.kind() == SyntaxKind::BLOCK_SCALAR) {
-      let range = block_scalar.text_range();
-      return self.apply_edit(range, value);
+      if plain {
+        return self.apply_edit(block_scalar.text_range(), value);
+      }
+
+      let source = self.source_text();
+      let new_text = Self::block_scalar_replacement(&source, &block_scalar, value);
+
+      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()))?;
+      let replacement = if plain { value.to_string() } else { crate::syntax::quote_scalar(value) };
 
-      return self.apply_edit(span.range, &replacement_text(&span, value));
+      return self.apply_edit(span.range, &replacement_text(&span, &replacement));
     }
 
     let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
-    self.replace_token(&scalar_token, value)
+    if plain {
+      return self.replace_token(&scalar_token, value);
+    }
+
+    let new_text = scalar_replacement_text(value, scalar_token.kind());
+
+    self.replace_token(&scalar_token, &new_text)
   }
 
   fn block_scalar_replacement(source: &str, block_scalar: &SyntaxNode, value: &str) -> String {

data/rust/src/document/style.rs

@@ -7,6 +7,13 @@ pub struct StyleEnforcement {
   pub value_style: Option<QuoteStyle>,
 }
 
+#[derive(Debug, Clone, Default)]
+pub struct BlankLineOptions {
+  pub before: Vec<String>,
+  pub after: Vec<String>,
+  pub skip_empty: bool,
+}
+
 impl Document {
   pub fn enforce_styles(&mut self, enforcement: &StyleEnforcement) -> Result<(), YerbaError> {
     let source = self.source_text();
@@ -588,6 +595,10 @@ impl Document {
   }
 
   pub fn enforce_blank_lines(&mut self, dot_path: &str, blank_lines: usize) -> Result<(), YerbaError> {
+    self.enforce_blank_lines_with(dot_path, blank_lines, &BlankLineOptions::default())
+  }
+
+  pub fn enforce_blank_lines_with(&mut self, dot_path: &str, blank_lines: usize, options: &BlankLineOptions) -> Result<(), YerbaError> {
     let nodes = if dot_path.contains('[') {
       self.navigate_all_compact(dot_path)
     } else {
@@ -597,14 +608,44 @@ impl Document {
     let mut edits: Vec<(TextRange, String)> = Vec::new();
 
     for current_node in &nodes {
-      let entry_nodes: Vec<SyntaxNode> = match first_collection(current_node) {
-        Some(FirstCollection::Sequence(sequence)) => sequence.entries().map(|entry| entry.syntax().clone()).collect(),
-        Some(FirstCollection::Map(map)) => map.entries().map(|entry| entry.syntax().clone()).collect(),
+      let entries: Vec<BlankLineEntry> = match first_collection(current_node) {
+        Some(FirstCollection::Sequence(sequence)) => sequence
+          .entries()
+          .map(|entry| BlankLineEntry {
+            is_empty: is_empty_value(&node_to_yaml_value(entry.syntax())),
+            node: entry.syntax().clone(),
+            key: None,
+          })
+          .collect(),
+
+        Some(FirstCollection::Map(map)) => map
+          .entries()
+          .map(|entry| {
+            let value = entry
+              .value()
+              .map(|value_node| node_to_yaml_value(value_node.syntax()))
+              .unwrap_or(yaml_serde::Value::Null);
+
+            BlankLineEntry {
+              key: entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())),
+              is_empty: is_empty_value(&value),
+              node: entry.syntax().clone(),
+            }
+          })
+          .collect(),
+
         None => continue,
       };
 
-      for entry_node in entry_nodes.iter().skip(1) {
-        collect_blank_line_edits(entry_node, blank_lines, &mut edits);
+      for index in 1..entries.len() {
+        let entry = &entries[index];
+        let previous = &entries[index - 1];
+
+        if !should_adjust_gap(entry, previous, options) {
+          continue;
+        }
+
+        collect_blank_line_edits(&entry.node, blank_lines, &mut edits);
       }
     }
 
@@ -738,6 +779,41 @@ impl Document {
     self.enforce_quotes_at(style, None)
   }
 
+  pub fn decode_escapes(&mut self, dot_path: Option<&str>) -> Result<usize, YerbaError> {
+    let scope_ranges: Vec<TextRange> = match dot_path {
+      Some(path) if !path.is_empty() => self.navigate_all_compact(path).iter().map(|node| node.text_range()).collect(),
+      _ => vec![self.root.text_range()],
+    };
+
+    let mut edits: Vec<(TextRange, String)> = Vec::new();
+
+    for element in self.root.descendants_with_tokens() {
+      let Some(token) = element.into_token() else { continue };
+
+      if token.kind() != SyntaxKind::DOUBLE_QUOTED_SCALAR {
+        continue;
+      }
+
+      if !scope_ranges.iter().any(|range| range.contains_range(token.text_range())) {
+        continue;
+      }
+
+      let Some(value) = raw_scalar_value(&token) else { continue };
+
+      let rewritten = format_scalar_value(&value, SyntaxKind::DOUBLE_QUOTED_SCALAR);
+
+      if rewritten != token.text() {
+        edits.push((token.text_range(), rewritten));
+      }
+    }
+
+    let count = edits.len();
+
+    self.apply_edits(edits)?;
+
+    Ok(count)
+  }
+
   pub fn enforce_quotes_at(&mut self, style: &QuoteStyle, dot_path: Option<&str>) -> Result<Vec<String>, YerbaError> {
     let source = self.source_text();
 
@@ -819,11 +895,7 @@ impl Document {
               let is_multiline = trimmed.contains('\n');
 
               let new_text = match style {
-                QuoteStyle::Double => {
-                  let escaped = trimmed.replace('\\', "\\\\").replace('"', "\\\"").replace('\n', "\\n");
-
-                  format!("\"{}\"", escaped)
-                }
+                QuoteStyle::Double => format_scalar_value(trimmed, SyntaxKind::DOUBLE_QUOTED_SCALAR),
 
                 QuoteStyle::Single => {
                   if is_multiline {
@@ -879,7 +951,7 @@ impl Document {
 
           let offset: usize = token.text_range().start().into();
           let line_prefix = &source[line_start_at(&source, offset)..offset];
-          let indent = line_prefix.len() - line_prefix.trim_start().len() + 2;
+          let indent = block_scalar_indent(line_prefix);
           let indent_str = " ".repeat(indent);
           let header = style.block_header();
 
@@ -932,6 +1004,54 @@ impl Document {
   }
 }
 
+struct BlankLineEntry {
+  node: SyntaxNode,
+  key: Option<String>,
+  is_empty: bool,
+}
+
+fn should_adjust_gap(entry: &BlankLineEntry, previous: &BlankLineEntry, options: &BlankLineOptions) -> bool {
+  let usable = |candidate: &BlankLineEntry| !options.skip_empty || !candidate.is_empty;
+
+  if options.before.is_empty() && options.after.is_empty() {
+    return usable(entry);
+  }
+
+  (matches_key(entry.key.as_deref(), &options.before) && usable(entry)) || (matches_key(previous.key.as_deref(), &options.after) && usable(previous))
+}
+
+fn matches_key(key: Option<&str>, keys: &[String]) -> bool {
+  match key {
+    Some(key) => keys.iter().any(|wanted| wanted == key),
+    None => false,
+  }
+}
+
+fn is_empty_value(value: &yaml_serde::Value) -> bool {
+  match value {
+    yaml_serde::Value::Null => true,
+    yaml_serde::Value::String(text) => text.is_empty(),
+    yaml_serde::Value::Sequence(entries) => entries.is_empty(),
+    yaml_serde::Value::Mapping(entries) => entries.is_empty(),
+    _ => false,
+  }
+}
+
+fn block_scalar_indent(line_prefix: &str) -> usize {
+  let mut column = 0;
+  let bytes = line_prefix.as_bytes();
+
+  while column < bytes.len() {
+    match bytes[column] {
+      b' ' => column += 1,
+      b'-' if bytes.get(column + 1) == Some(&b' ') => column += 2,
+      _ => break,
+    }
+  }
+
+  column + 2
+}
+
 fn inline_quote_replacement(raw_value: &str, current_kind: SyntaxKind, style: &QuoteStyle) -> Option<String> {
   match style {
     QuoteStyle::Double => {

data/rust/src/error.rs

@@ -10,6 +10,8 @@ pub enum YerbaError {
   IndexOutOfBounds(usize, usize),
   UnknownKeys(Vec<String>),
   DuplicateValues(Vec<crate::DuplicateInfo>),
+  ControlCharacters(Vec<crate::ControlCharacter>),
+  #[cfg(feature = "schema")]
   SchemaValidation(Vec<crate::schema::ValidationError>),
   DuplicateKey {
     key: String,
@@ -74,10 +76,24 @@ impl std::fmt::Display for YerbaError {
         write!(f, "found {} {}: {}", duplicates.len(), noun, details.join(", "))
       }
 
+      YerbaError::ControlCharacters(found) => {
+        let noun = if found.len() == 1 { "character" } else { "characters" };
+        let details: Vec<String> = found.iter().map(|control| format!("    {}", control)).collect();
+
+        write!(
+          f,
+          "found {} control {} that YAML parsers reject:\n{}\n\n  Control characters must be removed, or escaped as \\xNN inside a double-quoted value.\n",
+          found.len(),
+          noun,
+          details.join("\n")
+        )
+      }
+
       YerbaError::IndexOutOfBounds(index, length) => {
         write!(f, "index {} out of bounds (length {})", index, length)
       }
 
+      #[cfg(feature = "schema")]
       YerbaError::SchemaValidation(errors) => {
         let details: Vec<String> = errors.iter().map(|error| error.to_string()).collect();
 
@@ -137,6 +153,7 @@ impl GitHubAnnotations for YerbaError {
         })
         .collect(),
 
+      #[cfg(feature = "schema")]
       YerbaError::SchemaValidation(errors) => errors
         .iter()
         .map(|error| GitHubAnnotation {
@@ -147,6 +164,16 @@ impl GitHubAnnotations for YerbaError {
         })
         .collect(),
 
+      YerbaError::ControlCharacters(found) => found
+        .iter()
+        .map(|control| GitHubAnnotation {
+          level: "error ",
+          file: file.to_string(),
+          line: Some(control.line),
+          message: format!("control character U+{:04X} at column {}", control.character as u32, control.column),
+        })
+        .collect(),
+
       YerbaError::DuplicateKey { key, duplicate_line, .. } => vec![GitHubAnnotation {
         level: "error ",
         file: file.to_string(),

data/rust/src/ffi.rs

@@ -485,25 +485,34 @@ pub unsafe extern "C" fn yerba_document_find(document: *const Document, path: *c
   CString::new(json).unwrap_or_default().into_raw()
 }
 
+unsafe fn borrow_value<'a>(value: *const c_char, length: usize) -> &'a str {
+  if value.is_null() {
+    return "";
+  }
+
+  std::str::from_utf8(std::slice::from_raw_parts(value as *const u8, length)).unwrap_or("")
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_set(
   document: *mut Document,
   path: *const c_char,
   value: *const c_char,
+  value_length: usize,
   value_type: YerbaValueType,
+  plain: bool,
   all: bool,
 ) -> YerbaResult {
   let document = &mut *document;
   let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
-  let value_string = CStr::from_ptr(value).to_str().unwrap_or("");
-
-  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),
-    }
+  let value_string = borrow_value(value, value_length);
+  let verbatim = plain || value_type != YerbaValueType::String;
+
+  let result = match (all, verbatim) {
+    (true, false) => document.set_all(selector_string, value_string),
+    (true, true) => document.set_all_plain(selector_string, value_string),
+    (false, false) => document.set(selector_string, value_string),
+    (false, true) => document.set_plain(selector_string, value_string),
   };
 
   match result {
@@ -517,17 +526,25 @@ pub unsafe extern "C" fn yerba_document_insert(
   document: *mut Document,
   path: *const c_char,
   value: *const c_char,
+  value_length: usize,
   value_type: YerbaValueType,
+  plain: bool,
+  style: *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 raw_value = CStr::from_ptr(value).to_str().unwrap_or("");
+  let raw_value = borrow_value(value, value_length);
 
   let value_string = match value_type {
-    YerbaValueType::String => crate::syntax::quote_if_needed(raw_value),
+    YerbaValueType::String if !plain => {
+      let style = if style.is_null() { None } else { CStr::from_ptr(style).to_str().ok() };
+
+      crate::syntax::quote_scalar_styled(raw_value, style)
+    }
+
     _ => raw_value.to_string(),
   };
 
@@ -543,7 +560,13 @@ pub unsafe extern "C" fn yerba_document_insert(
     InsertPosition::Last
   };
 
-  match document.insert_into(selector_string, &value_string, position) {
+  let result = if plain {
+    document.insert_fragment_into(selector_string, &value_string, position)
+  } else {
+    document.insert_into(selector_string, &value_string, position)
+  };
+
+  match result {
     Ok(()) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }
@@ -746,6 +769,7 @@ pub unsafe extern "C" fn yerba_document_blank_lines(document: *mut Document, pat
 }
 
 /// Caller must free with yerba_string_free.
+#[cfg(feature = "schema")]
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_validate_schema(document: *const Document, schema_json: *const c_char, selector: *const c_char) -> *mut c_char {
   let document = &*document;
@@ -784,6 +808,7 @@ pub unsafe extern "C" fn yerba_document_validate_schema(document: *const Documen
 }
 
 /// Caller must free with yerba_string_free.
+#[cfg(feature = "cli")]
 #[no_mangle]
 pub unsafe extern "C" fn yerba_yerbafile_find(directory: *const c_char) -> *mut c_char {
   let start = if directory.is_null() {
@@ -803,6 +828,7 @@ pub unsafe extern "C" fn yerba_yerbafile_find(directory: *const c_char) -> *mut
   }
 }
 
+#[cfg(feature = "cli")]
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_apply_yerbafile(document: *mut Document, file_path: *const c_char, yerbafile_path: *const c_char) -> YerbaResult {
   let document = &mut *document;
@@ -840,6 +866,21 @@ pub unsafe extern "C" fn yerba_document_to_string(document: *const Document) ->
   CString::new(content).unwrap_or_default().into_raw()
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn yerba_quote_scalar(value: *const c_char, length: usize, style: *const c_char) -> *mut c_char {
+  let bytes = std::slice::from_raw_parts(value as *const u8, length);
+
+  let Ok(value) = std::str::from_utf8(bytes) else {
+    return std::ptr::null_mut();
+  };
+
+  let style = if style.is_null() { None } else { CStr::from_ptr(style).to_str().ok() };
+
+  CString::new(crate::syntax::quote_scalar_styled(value, style))
+    .map(|string| string.into_raw())
+    .unwrap_or(std::ptr::null_mut())
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_string_free(s: *mut c_char) {
   if !s.is_null() {
@@ -924,6 +965,7 @@ 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 {
   let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");
@@ -940,6 +982,7 @@ pub unsafe extern "C" fn yerba_document_get_all(document: *const Document, path:
   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 {
   let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");

data/rust/src/lib.rs

@@ -4,21 +4,29 @@ pub mod error;
 pub mod ffi;
 pub mod json;
 mod quote_style;
+#[cfg(feature = "schema")]
 pub mod schema;
 pub mod selector;
 mod syntax;
+mod validation;
 mod yaml_writer;
+#[cfg(feature = "cli")]
 pub mod yerbafile;
 
-pub use document::style::StyleEnforcement;
+pub use document::style::{BlankLineOptions, StyleEnforcement};
 pub use document::{
   collect_selectors, validate_condition, validate_item_condition, Document, DuplicateInfo, InsertPosition, LocatedNode, Location, NodeInfo, NodeType, SortField,
 };
 pub use error::YerbaError;
 pub use quote_style::{KeyStyle, QuoteStyle};
 pub use selector::Selector;
-pub use syntax::{detect_yaml_type, ScalarValue, YerbaValueType};
+pub use syntax::{
+  detect_yaml_type, escape_double_quoted, is_control_character, is_flow_collection, is_inline_scalar_safe, is_plain_safe, is_plain_safe_in_flow,
+  is_quoted_scalar, is_single_quotable, needs_quoting, needs_quoting_in_flow, quote_scalar, quote_scalar_styled, ScalarValue, YerbaValueType,
+};
+pub use validation::{find_control_characters, ControlCharacter};
 pub use yaml_writer::json_to_yaml_text;
+#[cfg(feature = "cli")]
 pub use yerbafile::Yerbafile;
 
 pub fn version() -> &'static str {
@@ -33,6 +41,7 @@ pub fn parse_file(path: impl AsRef<std::path::Path>) -> Result<Document, YerbaEr
   Document::parse_file(path)
 }
 
+#[cfg(feature = "glob")]
 pub fn glob_get(pattern: &str, selector: &str) -> Vec<document::LocatedNode> {
   use rayon::prelude::*;
 
@@ -55,6 +64,7 @@ pub fn glob_get(pattern: &str, selector: &str) -> Vec<document::LocatedNode> {
     .collect()
 }
 
+#[cfg(feature = "glob")]
 pub fn glob_find(pattern: &str, selector: &str, condition: Option<&str>, select: Option<&str>) -> Result<Vec<serde_json::Value>, YerbaError> {
   use rayon::prelude::*;