yerba 0.8.0 → 0.9.0

data/rust/src/document/insert.rs

@@ -89,6 +89,14 @@ impl Document {
   }
 
   pub fn insert_into(&mut self, dot_path: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
+    self.insert_with(dot_path, value, position, false)
+  }
+
+  pub fn insert_fragment_into(&mut self, dot_path: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
+    self.insert_with(dot_path, value, position, true)
+  }
+
+  fn insert_with(&mut self, dot_path: &str, value: &str, position: InsertPosition, fragment: bool) -> Result<(), YerbaError> {
     Self::validate_path(dot_path)?;
     self.refuse_flow_target(dot_path)?;
 
@@ -180,7 +188,7 @@ impl Document {
         };
 
         let indent = " ".repeat(start_col);
-        let new_entry_text = Self::format_map_entry(key, value, &indent);
+        let new_entry_text = Self::format_map_entry(key, value, &indent, fragment);
 
         match &position {
           InsertPosition::After(target_key) => {
@@ -218,7 +226,7 @@ impl Document {
       return Ok(());
     }
 
-    self.insert_map_key(parent_path, key, value, position)
+    self.insert_map_key(parent_path, key, value, position, fragment)
   }
 
   fn insert_sequence_item(&mut self, dot_path: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
@@ -339,7 +347,7 @@ impl Document {
     }
   }
 
-  fn insert_map_key(&mut self, dot_path: &str, key: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
+  fn insert_map_key(&mut self, dot_path: &str, key: &str, value: &str, position: InsertPosition, fragment: bool) -> Result<(), YerbaError> {
     let current_node = self.navigate(dot_path)?;
 
     let map = match find_block_map(&current_node) {
@@ -378,7 +386,7 @@ impl Document {
       .map(|entry| preceding_whitespace_indent(entry.syntax()))
       .unwrap_or_default();
 
-    let new_entry_text = Self::format_map_entry(key, value, &indent);
+    let new_entry_text = Self::format_map_entry(key, value, &indent, fragment);
 
     match position {
       InsertPosition::Last => {
@@ -422,7 +430,7 @@ impl Document {
         self.insert_after_node(target_entry.syntax(), &new_text)
       }
 
-      InsertPosition::BeforeCondition(_) | InsertPosition::AfterCondition(_) => self.insert_map_key(dot_path, key, value, InsertPosition::Last),
+      InsertPosition::BeforeCondition(_) | InsertPosition::AfterCondition(_) => self.insert_map_key(dot_path, key, value, InsertPosition::Last, fragment),
 
       InsertPosition::FromSortOrder(order) => {
         let new_key_position = order.iter().position(|ordered_key| ordered_key == key);
@@ -447,7 +455,7 @@ impl Document {
           None => InsertPosition::Last,
         };
 
-        self.insert_map_key(dot_path, key, value, resolved)
+        self.insert_map_key(dot_path, key, value, resolved, fragment)
       }
     }
   }
@@ -566,11 +574,15 @@ impl Document {
     Some((trailing[comment_start..].to_string(), rowan::TextSize::from((start + line_end) as u32)))
   }
 
-  fn format_map_entry(key: &str, value: &str, indent: &str) -> String {
-    let is_block_value = value.contains('\n') || value.starts_with("- ");
+  fn format_map_entry(key: &str, value: &str, indent: &str, fragment: bool) -> String {
+    let is_block_value = value.contains('\n') || value.starts_with("- ") || (fragment && is_block_collection(value));
 
     if !is_block_value {
-      return format!("{}: {}", key, value);
+      if crate::syntax::is_inline_scalar_safe(value) {
+        return format!("{}: {}", key, value);
+      }
+
+      return format!("{}: {}", key, crate::syntax::quote_scalar(value));
     }
 
     let value_indent = format!("{}  ", indent);
@@ -632,3 +644,7 @@ impl Document {
     }
   }
 }
+
+fn is_block_collection(value: &str) -> bool {
+  !crate::syntax::is_flow_collection(value) && !crate::syntax::is_quoted_scalar(value) && !crate::syntax::is_plain_safe(value)
+}

data/rust/src/document/mod.rs

@@ -1,13 +1,17 @@
 mod condition;
-pub use condition::{validate_condition, validate_item_condition};
 mod delete;
 mod get;
 mod insert;
-mod schema;
 mod set;
 mod sort;
-pub mod style;
 mod unique;
+
+#[cfg(feature = "schema")]
+mod schema;
+
+pub mod style;
+
+pub use condition::{validate_condition, validate_item_condition};
 pub use unique::DuplicateInfo;
 
 use crate::syntax::YerbaValueType;

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