yerba 0.8.0-arm-linux-gnu → 0.9.0-arm-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

@@ -33,7 +33,7 @@ pub fn detect_yaml_type(scalar: &ScalarValue) -> YerbaValueType {
 
 pub fn raw_scalar_value(token: &SyntaxToken) -> Option<String> {
   match token.kind() {
-    SyntaxKind::PLAIN_SCALAR => Some(token.text().to_string()),
+    SyntaxKind::PLAIN_SCALAR => Some(fold_flow_scalar(token.text())),
 
     SyntaxKind::DOUBLE_QUOTED_SCALAR => {
       let text = token.text();
@@ -65,8 +65,16 @@ pub fn extract_scalar(node: &SyntaxNode) -> Option<ScalarValue> {
     .filter_map(|element| element.into_token())
     .find(|token| token.kind() == SyntaxKind::BLOCK_SCALAR_TEXT)?;
 
+  let dedented = dedent_block_scalar(block_token.text());
+
+  let folded = node
+    .descendants()
+    .find(|descendant| descendant.kind() == SyntaxKind::BLOCK_SCALAR)
+    .map(|scalar| scalar.text().to_string().trim_start().starts_with('>'))
+    .unwrap_or(false);
+
   Some(ScalarValue {
-    text: dedent_block_scalar(block_token.text()),
+    text: if folded { fold_flow_scalar(&dedented) } else { dedented },
     kind: SyntaxKind::BLOCK_SCALAR_TEXT,
     file_path: None,
     selector: None,
@@ -168,10 +176,7 @@ pub fn find_scalar_token(node: &SyntaxNode) -> Option<SyntaxToken> {
 
 pub fn format_scalar_value(value: &str, kind: SyntaxKind) -> String {
   match kind {
-    SyntaxKind::DOUBLE_QUOTED_SCALAR => {
-      let escaped = value.replace('\\', "\\\\").replace('"', "\\\"");
-      format!("\"{}\"", escaped)
-    }
+    SyntaxKind::DOUBLE_QUOTED_SCALAR => format!("\"{}\"", escape_double_quoted(value)),
 
     SyntaxKind::SINGLE_QUOTED_SCALAR => {
       let escaped = value.replace('\'', "''");
@@ -182,14 +187,168 @@ pub fn format_scalar_value(value: &str, kind: SyntaxKind) -> String {
   }
 }
 
-pub fn quote_if_needed(value: &str) -> String {
-  if is_yaml_non_string(value) {
+pub fn is_control_character(character: char) -> bool {
+  matches!(character as u32, 0x00..=0x08 | 0x0b | 0x0c | 0x0e..=0x1f | 0x7f | 0x80..=0x84 | 0x86..=0x9f)
+}
+
+pub fn is_single_quotable(value: &str) -> bool {
+  !value.contains('\n') && !value.contains('\r') && !value.chars().any(is_control_character)
+}
+
+pub fn escape_double_quoted(value: &str) -> String {
+  let mut result = String::with_capacity(value.len());
+
+  for character in value.chars() {
+    match character {
+      '\\' => result.push_str("\\\\"),
+      '"' => result.push_str("\\\""),
+      '\n' => result.push_str("\\n"),
+      '\r' => result.push_str("\\r"),
+      '\t' => result.push_str("\\t"),
+      _ if is_control_character(character) => result.push_str(&format!("\\x{:02x}", character as u32)),
+      _ => result.push(character),
+    }
+  }
+
+  result
+}
+
+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.chars().any(is_control_character) {
+    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_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_scalar(value: &str) -> String {
+  if needs_quoting(value) {
     format_scalar_value(value, SyntaxKind::DOUBLE_QUOTED_SCALAR)
   } else {
     value.to_string()
   }
 }
 
+pub fn quote_scalar_styled(value: &str, style: Option<&str>) -> String {
+  match style {
+    Some("double") => format_scalar_value(value, SyntaxKind::DOUBLE_QUOTED_SCALAR),
+    Some("single") if is_single_quotable(value) => format_scalar_value(value, SyntaxKind::SINGLE_QUOTED_SCALAR),
+
+    _ => quote_scalar(value),
+  }
+}
+
 pub fn extract_scalar_text(node: &SyntaxNode) -> Option<String> {
   extract_scalar(node).map(|scalar| scalar.text)
 }
@@ -212,11 +371,114 @@ pub fn dedent_block_scalar(text: &str) -> String {
   dedented.trim().to_string()
 }
 
+fn push_hex_escape(result: &mut String, characters: &mut Scan<'_>, digits: usize) {
+  let escape: String = characters.clone().take(digits).collect();
+
+  let decoded = (escape.len() == digits && escape.chars().all(|character| character.is_ascii_hexdigit()))
+    .then(|| u32::from_str_radix(&escape, 16).ok().and_then(char::from_u32))
+    .flatten();
+
+  match decoded {
+    Some(character) => {
+      for _ in 0..digits {
+        characters.next();
+      }
+
+      result.push(character);
+    }
+
+    None => {
+      result.push('\\');
+      result.push(match digits {
+        2 => 'x',
+        4 => 'u',
+        _ => 'U',
+      });
+    }
+  }
+}
+
+type Scan<'a> = std::iter::Peekable<std::str::Chars<'a>>;
+
+fn skip_spaces(characters: &mut Scan<'_>) {
+  while matches!(characters.peek(), Some(' ' | '\t')) {
+    characters.next();
+  }
+}
+
+fn fold_break(result: &mut String, characters: &mut Scan<'_>) {
+  while result.ends_with(' ') || result.ends_with('\t') {
+    result.pop();
+  }
+
+  let mut breaks = 1;
+
+  loop {
+    skip_spaces(characters);
+
+    match characters.peek() {
+      Some('\n') => {
+        characters.next();
+        breaks += 1;
+      }
+
+      Some('\r') => {
+        characters.next();
+        characters.next_if_eq(&'\n');
+        breaks += 1;
+      }
+
+      _ => break,
+    }
+  }
+
+  if breaks == 1 {
+    result.push(' ');
+  } else {
+    result.extend(std::iter::repeat_n('\n', breaks - 1));
+  }
+}
+
+pub fn fold_flow_scalar(text: &str) -> String {
+  if !text.contains('\n') && !text.contains('\r') {
+    return text.to_string();
+  }
+
+  let mut result = String::with_capacity(text.len());
+  let mut characters = text.chars().peekable();
+
+  while let Some(character) = characters.next() {
+    match character {
+      '\n' => fold_break(&mut result, &mut characters),
+
+      '\r' => {
+        characters.next_if_eq(&'\n');
+        fold_break(&mut result, &mut characters);
+      }
+
+      _ => result.push(character),
+    }
+  }
+
+  result
+}
+
 pub fn unescape_double_quoted(text: &str) -> String {
   let mut result = String::with_capacity(text.len());
-  let mut chars = text.chars();
+  let mut chars = text.chars().peekable();
 
   while let Some(character) = chars.next() {
+    if character == '\n' {
+      fold_break(&mut result, &mut chars);
+      continue;
+    }
+
+    if character == '\r' {
+      chars.next_if_eq(&'\n');
+      fold_break(&mut result, &mut chars);
+      continue;
+    }
+
     if character == '\\' {
       match chars.next() {
         Some('n') => result.push('\n'),
@@ -232,7 +494,19 @@ pub fn unescape_double_quoted(text: &str) -> String {
         Some('v') => result.push('\u{0b}'),
         Some(' ') => result.push(' '),
         Some('_') => result.push('\u{a0}'),
-        Some('\n') => {} // line continuation: skip newline and leading whitespace
+        Some('N') => result.push('\u{85}'),
+        Some('L') => result.push('\u{2028}'),
+        Some('P') => result.push('\u{2029}'),
+        Some('x') => push_hex_escape(&mut result, &mut chars, 2),
+        Some('u') => push_hex_escape(&mut result, &mut chars, 4),
+        Some('U') => push_hex_escape(&mut result, &mut chars, 8),
+        Some('\n') => skip_spaces(&mut chars),
+
+        Some('\r') => {
+          chars.next_if_eq(&'\n');
+          skip_spaces(&mut chars);
+        }
+
         Some(other) => {
           result.push('\\');
           result.push(other);
@@ -248,7 +522,7 @@ pub fn unescape_double_quoted(text: &str) -> String {
 }
 
 pub fn unescape_single_quoted(text: &str) -> String {
-  text.replace("''", "'")
+  fold_flow_scalar(&text.replace("''", "'"))
 }
 
 pub fn line_at(source: &str, offset: usize) -> usize {

data/rust/src/validation.rs

@@ -0,0 +1,30 @@
+use crate::syntax::is_control_character;
+
+#[derive(Debug, Clone)]
+pub struct ControlCharacter {
+  pub character: char,
+  pub line: usize,
+  pub column: usize,
+}
+
+impl std::fmt::Display for ControlCharacter {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    write!(f, "U+{:04X} at line {}, column {}", self.character as u32, self.line, self.column)
+  }
+}
+
+pub fn find_control_characters(source: &str) -> Vec<ControlCharacter> {
+  source
+    .lines()
+    .enumerate()
+    .flat_map(|(index, line)| {
+      line.chars().enumerate().filter_map(move |(column, character)| {
+        is_control_character(character).then_some(ControlCharacter {
+          character,
+          line: index + 1,
+          column: column + 1,
+        })
+      })
+    })
+    .collect()
+}

data/rust/src/yaml_writer.rs

@@ -10,6 +10,8 @@ pub fn json_to_yaml_text(value: &Value, quote_style: &QuoteStyle, indent: usize)
       map
         .iter()
         .map(|(k, v)| match v {
+          Value::Array(arr) if arr.is_empty() => format!("{}{}: []", prefix, k),
+
           Value::Array(arr) => {
             let items: Vec<String> = arr
               .iter()
@@ -26,6 +28,8 @@ pub fn json_to_yaml_text(value: &Value, quote_style: &QuoteStyle, indent: usize)
             format!("{}{}:\n{}", prefix, k, items.join("\n"))
           }
 
+          Value::Object(inner_map) if inner_map.is_empty() => format!("{}{}: {{}}", prefix, k),
+
           Value::Object(_) => {
             let inner = json_to_yaml_text(v, quote_style, indent + 2);
             format!("{}{}:\n{}", prefix, k, inner)
@@ -69,8 +73,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()
       }
@@ -149,31 +153,15 @@ fn format_yaml_scalar(value: &Value, quote_style: &QuoteStyle) -> String {
     Value::Bool(boolean) => boolean.to_string(),
     Value::Number(number) => number.to_string(),
     Value::String(string) => match quote_style {
-      QuoteStyle::Double => {
-        let escaped = string.replace('\\', "\\\\").replace('"', "\\\"");
-
-        format!("\"{}\"", escaped)
-      }
-
-      QuoteStyle::Single => {
+      QuoteStyle::Single if crate::syntax::is_single_quotable(string) => {
         let escaped = string.replace('\'', "''");
 
         format!("'{}'", escaped)
       }
 
-      QuoteStyle::Plain => {
-        if crate::syntax::is_yaml_non_string(string) {
-          format!("\"{}\"", string.replace('"', "\\\""))
-        } else {
-          string.clone()
-        }
-      }
+      QuoteStyle::Plain if !crate::syntax::needs_quoting(string) => string.clone(),
 
-      _ => {
-        let escaped = string.replace('\\', "\\\\").replace('"', "\\\"");
-
-        format!("\"{}\"", escaped)
-      }
+      _ => crate::syntax::format_scalar_value(string, yaml_parser::SyntaxKind::DOUBLE_QUOTED_SCALAR),
     },
 
     Value::Array(array) => {

data/rust/src/yerbafile.rs

@@ -42,6 +42,7 @@ pub enum PipelineStep {
   Unique(UniqueConfig),
   Schema(SchemaConfig),
   FinalNewline(FinalNewlineConfig),
+  Escapes(EscapesConfig),
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -59,6 +60,12 @@ pub struct BlankLinesConfig {
   #[serde(default)]
   pub path: Option<String>,
   pub count: usize,
+  #[serde(default)]
+  pub before: Vec<String>,
+  #[serde(default)]
+  pub after: Vec<String>,
+  #[serde(default)]
+  pub skip_empty: bool,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -102,6 +109,12 @@ pub struct FinalNewlineConfig {
   pub count: usize,
 }
 
+#[derive(Debug, Clone, Deserialize)]
+pub struct EscapesConfig {
+  #[serde(default)]
+  pub path: Option<String>,
+}
+
 fn default_one() -> usize {
   1
 }
@@ -199,13 +212,18 @@ impl<'de> Deserialize<'de> for PipelineStep {
       return Ok(PipelineStep::Schema(config));
     }
 
+    if let Some(value) = mapping.get(yaml_serde::Value::String("escapes".to_string())) {
+      let config: EscapesConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+      return Ok(PipelineStep::Escapes(config));
+    }
+
     if let Some(value) = mapping.get(yaml_serde::Value::String("final_newline".to_string())) {
       let config: FinalNewlineConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::FinalNewline(config));
     }
 
     Err(serde::de::Error::custom(
-      "unknown pipeline step: expected sort_keys, quote_style, collection_style, sequence_indent, set, insert, delete, rename, remove, blank_lines, sort, directives, unique, schema, or final_newline",
+      "unknown pipeline step: expected sort_keys, quote_style, collection_style, sequence_indent, set, insert, delete, rename, remove, blank_lines, sort, directives, unique, schema, escapes, or final_newline",
     ))
   }
 }
@@ -246,6 +264,8 @@ pub struct SetConfig {
   pub value: String,
   #[serde(default)]
   pub condition: Option<String>,
+  #[serde(default)]
+  pub plain: bool,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -254,6 +274,8 @@ pub struct InsertConfig {
   pub value: String,
   #[serde(default)]
   pub condition: Option<String>,
+  #[serde(default)]
+  pub plain: bool,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -432,6 +454,14 @@ impl Yerbafile {
 
     let original = document.to_string();
 
+    if let Some(error) = control_character_error(&original) {
+      return RuleResult {
+        file: file.to_string(),
+        changed: false,
+        error: Some(error),
+      };
+    }
+
     if run_global {
       if let Err(error) = execute_pipeline(&mut document, &self.pipeline, None, file, self) {
         return RuleResult {
@@ -513,6 +543,14 @@ impl Yerbafile {
 
     let original = document.to_string();
 
+    if let Some(error) = control_character_error(&original) {
+      return RuleResult {
+        file: file.to_string(),
+        changed: false,
+        error: Some(error),
+      };
+    }
+
     if let Err(error) = execute_pipeline(&mut document, &self.pipeline, None, file, self) {
       return RuleResult {
         file: file.to_string(),
@@ -574,6 +612,11 @@ impl Yerbafile {
 
   pub fn apply_to_document(&self, document: &mut Document, file_path: &str) -> Result<bool, YerbaError> {
     let original = document.to_string();
+
+    if let Some(error) = control_character_error(&original) {
+      return Err(error);
+    }
+
     let relative_path = self.relativize_path(file_path);
     let match_path = relative_path.as_deref().unwrap_or(file_path);
 
@@ -603,6 +646,12 @@ impl Yerbafile {
   }
 }
 
+fn control_character_error(source: &str) -> Option<YerbaError> {
+  let found = crate::validation::find_control_characters(source);
+
+  (!found.is_empty()).then_some(YerbaError::ControlCharacters(found))
+}
+
 fn execute_pipeline(document: &mut Document, steps: &[PipelineStep], base_path: Option<&str>, file: &str, yerbafile: &Yerbafile) -> Result<(), YerbaError> {
   use crate::document::style::StyleEnforcement;
 
@@ -704,7 +753,11 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
         }
       }
 
-      document.set(&full_path, &config.value)
+      if config.plain {
+        document.set_plain(&full_path, &config.value)
+      } else {
+        document.set(&full_path, &config.value)
+      }
     }
 
     PipelineStep::Insert(config) => {
@@ -718,7 +771,13 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
         }
       }
 
-      document.insert_into(&full_path, &config.value, crate::InsertPosition::Last)
+      let value = if config.plain {
+        config.value.clone()
+      } else {
+        crate::syntax::quote_scalar(&config.value)
+      };
+
+      document.insert_into(&full_path, &value, crate::InsertPosition::Last)
     }
 
     PipelineStep::Delete(config) => {
@@ -784,7 +843,13 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
     PipelineStep::BlankLines(config) => {
       let full_path = resolve_step_path(base_path, config.path.as_deref());
 
-      document.enforce_blank_lines(&full_path, config.count)
+      let options = crate::BlankLineOptions {
+        before: config.before.clone(),
+        after: config.after.clone(),
+        skip_empty: config.skip_empty,
+      };
+
+      document.enforce_blank_lines_with(&full_path, config.count, &options)
     }
 
     PipelineStep::Sort(config) => {
@@ -848,6 +913,13 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
     }
 
     PipelineStep::FinalNewline(config) => document.enforce_final_newline(config.count),
+
+    PipelineStep::Escapes(config) => {
+      let full_path = resolve_step_path(base_path, config.path.as_deref());
+      let scope = if full_path.is_empty() { None } else { Some(full_path.as_str()) };
+
+      document.decode_escapes(scope).map(|_| ())
+    }
   }
 }