yerba 0.7.6-x86_64-linux-gnu → 0.8.1-x86_64-linux-gnu

data/rust/src/ffi.rs

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

data/rust/src/json.rs

@@ -71,6 +71,12 @@ pub fn resolve_select_field(value: &yaml_serde::Value, field: &str) -> serde_jso
           }
         }
 
+        SelectorSegment::AllKeys => {
+          if let yaml_serde::Value::Mapping(mapping) = current {
+            next_values.extend(mapping.iter().map(|(_, entry)| entry.clone()));
+          }
+        }
+
         SelectorSegment::Index(index) => {
           if let yaml_serde::Value::Sequence(sequence) = current {
             if let Some(item) = sequence.get(*index) {
@@ -96,7 +102,10 @@ pub fn resolve_select_field(value: &yaml_serde::Value, field: &str) -> serde_jso
     current_values = next_values;
   }
 
-  let used_all_items = parsed.segments().iter().any(|s| matches!(s, SelectorSegment::AllItems));
+  let used_all_items = parsed
+    .segments()
+    .iter()
+    .any(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::AllKeys));
 
   if current_values.is_empty() {
     if used_all_items {

data/rust/src/lib.rs

@@ -4,19 +4,27 @@ pub mod error;
 pub mod ffi;
 pub mod json;
 mod quote_style;
+#[cfg(feature = "schema")]
 pub mod schema;
 pub mod selector;
 mod syntax;
 mod yaml_writer;
+#[cfg(feature = "cli")]
 pub mod yerbafile;
 
 pub use document::style::StyleEnforcement;
-pub use document::{collect_selectors, Document, DuplicateInfo, InsertPosition, LocatedNode, Location, NodeInfo, NodeType, SortField};
+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, is_flow_collection, is_inline_scalar_safe, is_plain_safe, is_plain_safe_in_flow, is_quoted_scalar, is_raw_yaml_text, is_valid_inline_value,
+  needs_quoting, needs_quoting_in_flow, quote_if_needed, ScalarValue, YerbaValueType,
+};
 pub use yaml_writer::json_to_yaml_text;
+#[cfg(feature = "cli")]
 pub use yerbafile::Yerbafile;
 
 pub fn version() -> &'static str {
@@ -31,6 +39,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::*;
 
@@ -53,24 +62,29 @@ pub fn glob_get(pattern: &str, selector: &str) -> Vec<document::LocatedNode> {
     .collect()
 }
 
-pub fn glob_find(pattern: &str, selector: &str, condition: Option<&str>, select: Option<&str>) -> Vec<serde_json::Value> {
+#[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::*;
 
+  if let Some(cond) = condition {
+    crate::document::validate_condition(cond)?;
+  }
+
   let files = match glob::glob(pattern) {
     Ok(paths) => paths.filter_map(|p| p.ok()).collect::<Vec<_>>(),
-    Err(_) => return vec![],
+    Err(_) => return Ok(vec![]),
   };
 
   let select_fields: Option<Vec<&str>> = select.map(|s| s.split(',').collect());
 
-  files
+  let 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 {
-          Some(cond) => document.filter(selector, cond),
+          Some(cond) => document.filter(selector, cond).unwrap_or_default(),
           None => document.get_values(selector),
         };
 
@@ -108,5 +122,7 @@ pub fn glob_find(pattern: &str, selector: &str, condition: Option<&str>, select:
 
       file_results
     })
-    .collect()
+    .collect();
+
+  Ok(results)
 }

data/rust/src/main.rs

@@ -20,6 +20,7 @@ static HELP: LazyLock<String> = LazyLock::new(|| {
       key.nested           Nested key path       "database.settings.pool"
       []                   All items in array    "[].title"
       [N]                  Item at index         "[0].title"
+      *                    All values in a map   "database.*"
       [].key[].nested      Nested array access   "[].speakers[].name"
 
     Conditions:

data/rust/src/quote_style.rs

@@ -1,7 +1,7 @@
-use clap::ValueEnum;
 use yaml_parser::SyntaxKind;
 
-#[derive(Debug, Clone, PartialEq, ValueEnum)]
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "cli", derive(clap::ValueEnum))]
 pub enum KeyStyle {
   /// Unquoted key (host:)
   Plain,
@@ -34,33 +34,34 @@ impl KeyStyle {
   }
 }
 
-#[derive(Debug, Clone, PartialEq, ValueEnum)]
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "cli", derive(clap::ValueEnum))]
 pub enum QuoteStyle {
   /// Unquoted value (host: localhost)
   Plain,
   /// Single-quoted value (host: 'localhost')
-  #[value(alias = "single-quoted")]
+  #[cfg_attr(feature = "cli", value(alias = "single-quoted"))]
   Single,
   /// Double-quoted value (host: "localhost")
-  #[value(alias = "double-quoted")]
+  #[cfg_attr(feature = "cli", value(alias = "double-quoted"))]
   Double,
   /// Literal block scalar, strip trailing newline (|-)
-  #[value(alias = "block-literal", alias = "|-")]
+  #[cfg_attr(feature = "cli", value(alias = "block-literal", alias = "|-"))]
   Literal,
   /// Literal block scalar, keep one trailing newline (|)
-  #[value(alias = "|")]
+  #[cfg_attr(feature = "cli", value(alias = "|"))]
   LiteralClip,
   /// Literal block scalar, keep all trailing newlines (|+)
-  #[value(alias = "|+")]
+  #[cfg_attr(feature = "cli", value(alias = "|+"))]
   LiteralKeep,
   /// Folded block scalar, strip trailing newline (>-)
-  #[value(alias = "block-folded", alias = ">-")]
+  #[cfg_attr(feature = "cli", value(alias = "block-folded", alias = ">-"))]
   Folded,
   /// Folded block scalar, keep one trailing newline (>)
-  #[value(alias = ">")]
+  #[cfg_attr(feature = "cli", value(alias = ">"))]
   FoldedClip,
   /// Folded block scalar, keep all trailing newlines (>+)
-  #[value(alias = ">+")]
+  #[cfg_attr(feature = "cli", value(alias = ">+"))]
   FoldedKeep,
 }
 

data/rust/src/selector.rs

@@ -21,6 +21,7 @@ pub enum Selector {
 pub enum SelectorSegment {
   Key(String),
   AllItems,
+  AllKeys,
   Index(usize),
 }
 
@@ -69,7 +70,10 @@ impl Selector {
   }
 
   pub fn has_wildcard(&self) -> bool {
-    self.segments().iter().any(|s| matches!(s, SelectorSegment::AllItems))
+    self
+      .segments()
+      .iter()
+      .any(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::AllKeys))
   }
 
   /// Split into the container selector (up to and including the last []) and the remaining field selector.
@@ -163,6 +167,14 @@ impl Selector {
           result.push_str("[]");
         }
 
+        SelectorSegment::AllKeys => {
+          if index > 0 && !result.ends_with('.') {
+            result.push('.');
+          }
+
+          result.push('*');
+        }
+
         SelectorSegment::Index(i) => {
           result.push_str(&format!("[{}]", i));
         }
@@ -227,7 +239,9 @@ fn parse_segments(input: &str) -> Vec<SelectorSegment> {
         Some(index) => {
           let key = &rest[..index];
 
-          if !key.is_empty() {
+          if key == "*" {
+            segments.push(SelectorSegment::AllKeys);
+          } else if !key.is_empty() {
             segments.push(SelectorSegment::Key(key.to_string()));
           }
 
@@ -238,7 +252,9 @@ fn parse_segments(input: &str) -> Vec<SelectorSegment> {
           }
         }
         None => {
-          if !rest.is_empty() {
+          if rest == "*" {
+            segments.push(SelectorSegment::AllKeys);
+          } else if !rest.is_empty() {
             segments.push(SelectorSegment::Key(rest.to_string()));
           }
 

data/rust/src/syntax.rs

@@ -1,7 +1,7 @@
 use rowan::ast::AstNode;
 use rowan::{TextRange, TextSize};
 
-use yaml_parser::ast::{BlockMap, BlockMapEntry, BlockSeq};
+use yaml_parser::ast::{BlockMap, BlockMapEntry, BlockSeq, FlowMap, FlowMapEntry, FlowSeq};
 use yaml_parser::{SyntaxKind, SyntaxNode, SyntaxToken};
 
 #[derive(Debug, Clone, PartialEq)]
@@ -82,6 +82,46 @@ pub fn find_block_sequence(node: &SyntaxNode) -> Option<BlockSeq> {
   node.descendants().find_map(BlockSeq::cast)
 }
 
+fn first_collection_node(node: &SyntaxNode) -> Option<SyntaxNode> {
+  node.descendants().find(|descendant| {
+    matches!(
+      descendant.kind(),
+      SyntaxKind::BLOCK_MAP | SyntaxKind::BLOCK_SEQ | SyntaxKind::FLOW_MAP | SyntaxKind::FLOW_SEQ
+    )
+  })
+}
+
+pub fn find_flow_sequence(node: &SyntaxNode) -> Option<FlowSeq> {
+  first_collection_node(node).and_then(FlowSeq::cast)
+}
+
+pub fn find_flow_map(node: &SyntaxNode) -> Option<FlowMap> {
+  first_collection_node(node).and_then(FlowMap::cast)
+}
+
+pub fn flow_sequence_entries(sequence: &FlowSeq) -> Vec<SyntaxNode> {
+  sequence
+    .entries()
+    .map(|entries| entries.entries().map(|entry| entry.syntax().clone()).collect())
+    .unwrap_or_default()
+}
+
+pub fn flow_map_entries(map: &FlowMap) -> Vec<FlowMapEntry> {
+  map.entries().map(|entries| entries.entries().collect()).unwrap_or_default()
+}
+
+pub fn find_flow_entry_by_key(map: &FlowMap, key: &str) -> Option<FlowMapEntry> {
+  flow_map_entries(map)
+    .into_iter()
+    .find(|entry| entry.key().and_then(|found| extract_scalar_text(found.syntax())).as_deref() == Some(key))
+}
+
+pub fn in_flow_collection(node: &SyntaxNode) -> bool {
+  node
+    .ancestors()
+    .any(|ancestor| matches!(ancestor.kind(), SyntaxKind::FLOW_MAP | SyntaxKind::FLOW_SEQ))
+}
+
 pub enum FirstCollection {
   Map(BlockMap),
   Sequence(BlockSeq),
@@ -142,8 +182,139 @@ pub fn format_scalar_value(value: &str, kind: SyntaxKind) -> String {
   }
 }
 
+const LEADING_INDICATORS: [char; 16] = ['#', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`', ',', '[', ']', '{', '}'];
+const FLOW_INDICATORS: [char; 5] = [',', '[', ']', '{', '}'];
+
+pub fn is_plain_safe(value: &str) -> bool {
+  if value.is_empty() || value != value.trim() {
+    return false;
+  }
+
+  if value.contains('\n') || value.contains('\t') {
+    return false;
+  }
+
+  if value.contains(": ") || value.ends_with(':') {
+    return false;
+  }
+
+  if value.contains(" #") {
+    return false;
+  }
+
+  if value.starts_with("---") || value.starts_with("...") {
+    return false;
+  }
+
+  let mut characters = value.chars();
+  let first = characters.next().expect("value is non-empty");
+
+  if LEADING_INDICATORS.contains(&first) {
+    return false;
+  }
+
+  if matches!(first, '-' | '?' | ':') {
+    return matches!(characters.next(), Some(next) if next != ' ');
+  }
+
+  true
+}
+
+pub fn is_plain_safe_in_flow(value: &str) -> bool {
+  is_plain_safe(value) && !value.contains(FLOW_INDICATORS)
+}
+
+pub fn is_quoted_scalar(value: &str) -> bool {
+  let bytes = value.as_bytes();
+
+  if bytes.len() < 2 {
+    return false;
+  }
+
+  match (bytes[0], bytes[bytes.len() - 1]) {
+    (b'"', b'"') => {
+      let interior = &value[1..value.len() - 1];
+      let mut escaped = false;
+
+      for character in interior.chars() {
+        if escaped {
+          escaped = false;
+          continue;
+        }
+
+        match character {
+          '\\' => escaped = true,
+          '"' => return false,
+          _ => {}
+        }
+      }
+
+      !escaped
+    }
+
+    (b'\'', b'\'') => {
+      let interior = &value[1..value.len() - 1];
+      let mut characters = interior.chars().peekable();
+
+      while let Some(character) = characters.next() {
+        if character == '\'' {
+          if characters.peek() == Some(&'\'') {
+            characters.next();
+          } else {
+            return false;
+          }
+        }
+      }
+
+      true
+    }
+
+    _ => false,
+  }
+}
+
+pub fn is_flow_collection(value: &str) -> bool {
+  (value.starts_with('[') && value.ends_with(']')) || (value.starts_with('{') && value.ends_with('}'))
+}
+
+pub fn is_raw_yaml_text(value: &str) -> bool {
+  value.contains('\n') || value.starts_with("- ") || is_quoted_scalar(value) || is_flow_collection(value)
+}
+
+pub fn is_valid_inline_value(value: &str) -> bool {
+  if value.is_empty() {
+    return true;
+  }
+
+  is_raw_yaml_text(value) || is_plain_safe(value)
+}
+
+pub fn is_inline_scalar_safe(value: &str) -> bool {
+  if value.is_empty() {
+    return true;
+  }
+
+  if value.contains('\n') || value.starts_with("- ") {
+    return false;
+  }
+
+  is_quoted_scalar(value) || is_flow_collection(value) || is_plain_safe(value)
+}
+
+pub fn needs_quoting(value: &str) -> bool {
+  is_yaml_non_string(value) || !is_plain_safe(value)
+}
+
+pub fn needs_quoting_in_flow(value: &str) -> bool {
+  is_yaml_non_string(value) || !is_plain_safe_in_flow(value)
+}
+
 pub fn quote_if_needed(value: &str) -> String {
-  if is_yaml_non_string(value) {
+  if is_raw_yaml_text(value) {
+    return value.to_string();
+  }
+
+  if needs_quoting(value) {
     format_scalar_value(value, SyntaxKind::DOUBLE_QUOTED_SCALAR)
   } else {
     value.to_string()
@@ -288,7 +459,7 @@ pub fn is_yaml_non_string(value: &str) -> bool {
 }
 
 pub fn is_yaml_truthy(value: &str) -> bool {
-  matches!(value, "true" | "True" | "TRUE" | "yes" | "Yes" | "YES" | "on" | "On" | "ON" | "y" | "Y")
+  matches!(value, "true" | "True" | "TRUE" | "yes" | "Yes" | "YES" | "on" | "On" | "ON")
 }
 
 pub fn detect_yaml_type_from_plain(value: &str) -> YerbaValueType {
@@ -297,31 +468,12 @@ pub fn detect_yaml_type_from_plain(value: &str) -> YerbaValueType {
     return YerbaValueType::Null;
   }
 
-  // Boolean (YAML 1.2 + 1.1)
+  // Boolean, resolved the way libyaml/Psych resolve it: the YAML 1.1 bool set
+  // without the single-letter y/Y/n/N forms (which libyaml treats as strings),
+  // and broader than YAML 1.2 core schema (which only accepts true/false).
   if matches!(
     value,
-    "true"
-      | "True"
-      | "TRUE"
-      | "false"
-      | "False"
-      | "FALSE"
-      | "yes"
-      | "Yes"
-      | "YES"
-      | "no"
-      | "No"
-      | "NO"
-      | "on"
-      | "On"
-      | "ON"
-      | "off"
-      | "Off"
-      | "OFF"
-      | "y"
-      | "Y"
-      | "n"
-      | "N"
+    "true" | "True" | "TRUE" | "false" | "False" | "FALSE" | "yes" | "Yes" | "YES" | "no" | "No" | "NO" | "on" | "On" | "ON" | "off" | "Off" | "OFF"
   ) {
     return YerbaValueType::Boolean;
   }

data/rust/src/yaml_writer.rs

@@ -69,8 +69,8 @@ pub fn yaml_value_to_flow_text(value: &yaml_serde::Value) -> String {
     yaml_serde::Value::Number(number) => number.to_string(),
 
     yaml_serde::Value::String(string) => {
-      if crate::syntax::is_yaml_non_string(string) {
-        format!("\"{}\"", string.replace('"', "\\\""))
+      if crate::syntax::needs_quoting_in_flow(string) {
+        crate::syntax::format_scalar_value(string, yaml_parser::SyntaxKind::DOUBLE_QUOTED_SCALAR)
       } else {
         string.clone()
       }
@@ -162,8 +162,8 @@ fn format_yaml_scalar(value: &Value, quote_style: &QuoteStyle) -> String {
       }
 
       QuoteStyle::Plain => {
-        if crate::syntax::is_yaml_non_string(string) {
-          format!("\"{}\"", string.replace('"', "\\\""))
+        if crate::syntax::needs_quoting(string) {
+          crate::syntax::format_scalar_value(string, yaml_parser::SyntaxKind::DOUBLE_QUOTED_SCALAR)
         } else {
           string.clone()
         }