yerba 0.8.0-x86_64-linux-gnu → 0.8.1-x86_64-linux-gnu

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/syntax.rs

@@ -182,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()

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()
         }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: x86_64-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-07-26 00:00:00.000000000 Z
+date: 2026-07-30 00:00:00.000000000 Z
 dependencies: []
 description: A CLI tool for editing YAML while preserving structure, comments, and
   format.
@@ -68,6 +68,7 @@ files:
 - rust/src/commands/set.rs
 - rust/src/commands/sort.rs
 - rust/src/commands/sort_keys.rs
+- rust/src/commands/ui.rs
 - rust/src/commands/unique.rs
 - rust/src/commands/version.rs
 - rust/src/didyoumean.rs