yerba 0.8.1-arm-linux-gnu → 0.9.1-arm-linux-gnu

data/rust/src/commands/blank_lines.rs

@@ -11,6 +11,8 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
     yerba blank-lines videos.yml "[]" 1
     yerba blank-lines videos.yml "[].speakers" 1
     yerba blank-lines config.yml "tags" 0
+    yerba blank-lines event.yml "" 1 --before "schedule,speakers"
+    yerba blank-lines event.yml "" 1 --after "location" --skip-empty
   "#})
 });
 
@@ -26,6 +28,15 @@ pub struct Args {
   first: String,
   /// Count (when selector is provided as first positional)
   second: Option<usize>,
+  /// Comma-separated map keys to separate from what precedes them
+  #[arg(long)]
+  before: Option<String>,
+  /// Comma-separated map keys to separate from what follows them
+  #[arg(long)]
+  after: Option<String>,
+  /// Leave entries alone when their value is null, an empty collection, or an empty string
+  #[arg(long)]
+  skip_empty: bool,
   #[arg(long)]
   dry_run: bool,
 }
@@ -44,12 +55,22 @@ impl Args {
       std::process::exit(1);
     };
 
+    let options = yerba::BlankLineOptions {
+      before: split_keys(self.before.as_deref()),
+      after: split_keys(self.after.as_deref()),
+      skip_empty: self.skip_empty,
+    };
+
     for resolved_file in resolve_files(&self.file) {
       let mut document = parse_file(&resolved_file);
 
-      if document.enforce_blank_lines(selector, count).is_ok() {
+      if document.enforce_blank_lines_with(selector, count, &options).is_ok() {
         output(&resolved_file, &document, self.dry_run);
       }
     }
   }
 }
+
+fn split_keys(keys: Option<&str>) -> Vec<String> {
+  keys.map(|keys| keys.split(',').map(|key| key.trim().to_string()).collect()).unwrap_or_default()
+}

data/rust/src/commands/init.rs

@@ -45,6 +45,12 @@ pub fn run() {
     #       # Enforce blank lines between sequence entries
     #       - blank_lines:
     #           count: 1
+    #           # skip_empty: true      # leave null/empty entries packed
+    #           # before:               # separate these keys from what precedes them
+    #           #   - schedule
+    #           #   - speakers
+    #           # after:                # separate these keys from what follows them
+    #           #   - location
     #
     #       # Set a value (with optional condition)
     #       - set:

data/rust/src/commands/insert.rs

@@ -8,13 +8,13 @@ use super::{output, parse_file, resolve_files, run_op};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
-    yerba insert config.yml "database.ssl" true
-    yerba insert config.yml "database.ssl" true --after "host"
-    yerba insert config.yml "database.ssl" true --before "port"
+    yerba insert config.yml "database.ssl" true --plain
+    yerba insert config.yml "database.ssl" true --plain --after "host"
+    yerba insert config.yml "database.ssl" true --plain --before "port"
     yerba insert config.yml "tags" "yaml"
     yerba insert config.yml "tags" "yaml" --at 0
     yerba insert config.yml "tags" "yaml" --after "ruby"
-    yerba insert speakers.yml "" "name: Bob" --after ".name == Alice"
+    yerba insert speakers.yml "" "name: Bob" --plain --after ".name == Alice"
     yerba insert videos.yml "[0].speakers" "Diana" --before ".name == Charlie"
     yerba insert videos.yml "" --from "new_talk.yml" --after ".id == first-talk"
   "#})
@@ -39,6 +39,8 @@ pub struct Args {
   after: Option<String>,
   #[arg(long)]
   at: Option<usize>,
+  #[arg(long, help = "Write the value as raw YAML, for literals like null, true or 42 and for map or sequence fragments")]
+  plain: bool,
   #[arg(long)]
   dry_run: bool,
 }
@@ -67,8 +69,12 @@ impl Args {
           .trim()
           .to_string()
       }
-    } else if let Some(val) = self.value {
-      val
+    } else if let Some(value) = self.value {
+      if self.plain {
+        value
+      } else {
+        yerba::quote_scalar(&value)
+      }
     } else {
       eprintln!("{} either a value argument or --from is required", ui::failure("Error:"));
 

data/rust/src/commands/mod.rs

@@ -188,11 +188,10 @@ pub(crate) fn run_yerbafile(write: bool, files: Vec<String>) {
     process::exit(1);
   });
 
-  eprintln!("{}", ui::banner());
+  eprintln!("\n{}\n", ui::banner());
 
   eprintln!(
-    "{}{} {}\n",
-    ui::INDENT,
+    "{} {}\n",
     ui::strong("Using Yerbafile rules"),
     ui::subtle(format!("(from {})", yerbafile_path.display()))
   );

data/rust/src/commands/set.rs

@@ -11,8 +11,11 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
     yerba set config.yml "database.host" "0.0.0.0" --if-exists
     yerba set config.yml "database.host" "0.0.0.0" --condition ".port == 5432"
     yerba set videos.yml "[0].title" "New Title"
+    yerba set videos.yml "[].title" "New Title" --condition ".id == talk-1"
     yerba set "data/**/event.yml" "website" "" --if-exists
     yerba set videos.yml "[].description" "" --all
+    yerba set config.yml "database.replica" null --plain
+    yerba set videos.yml "[].published" false --plain --all
   "#})
 });
 
@@ -35,6 +38,8 @@ pub struct Args {
   condition: Option<String>,
   #[arg(long)]
   all: bool,
+  #[arg(long, help = "Write the value unquoted, for YAML literals like null, true or 42")]
+  plain: bool,
   #[arg(long)]
   dry_run: bool,
 }
@@ -53,6 +58,9 @@ impl Args {
       }
     }
 
+    let leaf = self.selector.rsplit_once('.').map(|(_, leaf)| leaf).unwrap_or(&self.selector);
+    let per_item = yerba::Selector::parse(parent_path).has_brackets();
+
     for resolved_file in resolve_files(&self.file) {
       let mut document = parse_file(&resolved_file);
 
@@ -61,16 +69,18 @@ impl Args {
       } else if self.if_missing {
         !document.exists(&self.selector)
       } else if let Some(condition) = &self.condition {
-        document.evaluate_condition(parent_path, condition).unwrap_or(false)
+        per_item || document.evaluate_condition(parent_path, condition).unwrap_or(false)
       } else {
         true
       };
 
       if should_set {
-        let result = if self.all {
-          document.set_all(&self.selector, &self.value)
-        } else {
-          document.set(&self.selector, &self.value)
+        let result = match &self.condition {
+          Some(condition) if per_item => document.set_where(parent_path, leaf, &self.value, condition, self.all, self.plain).map(|_| ()),
+          _ if self.all && self.plain => document.set_all_plain(&self.selector, &self.value),
+          _ if self.all => document.set_all(&self.selector, &self.value),
+          _ if self.plain => document.set_plain(&self.selector, &self.value),
+          _ => document.set(&self.selector, &self.value),
         };
 
         run_op_with_hint(

data/rust/src/commands/ui.rs

@@ -110,10 +110,9 @@ pub fn strong(text: impl std::fmt::Display) -> String {
 }
 
 pub fn banner() -> String {
-  format!("🧉 {} {}", Style::fg(GREEN).bold().paint("yerba"), subtle(format!("v{}", yerba::version())))
+  format!("{} 🧉 {}", strong("Yerba"), subtle(format!("v{}", yerba::version())))
 }
 
-pub const INDENT: &str = "   ";
 pub const STATUS_INDENT: &str = "  ";
 
 pub mod glyph {

data/rust/src/commands/version.rs

@@ -3,7 +3,7 @@ use super::ui;
 pub fn run() {
   println!("{}", ui::banner());
   println!(
-    "   {}{} {}{} {}{} {}{} {}{}",
+    "{}{} {}{} {}{} {}{} {}{}",
     ui::strong("Y"),
     ui::subtle("AML"),
     ui::strong("E"),

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,15 +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 {
-      if !crate::syntax::is_valid_inline_value(value) {
-        return format!("{}: {}", key, crate::syntax::quote_if_needed(value));
+      if crate::syntax::is_inline_scalar_safe(value) {
+        return format!("{}: {}", key, value);
       }
 
-      return format!("{}: {}", key, value);
+      return format!("{}: {}", key, crate::syntax::quote_scalar(value));
     }
 
     let value_indent = format!("{}  ", indent);
@@ -636,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

@@ -31,6 +31,7 @@ pub struct LocatedNode {
 
 use std::fs;
 use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
 
 use rowan::ast::AstNode;
 use rowan::{TextRange, TextSize};
@@ -126,10 +127,13 @@ pub enum InsertPosition {
   FromSortOrder(Vec<String>),
 }
 
+static NEXT_GENERATION: AtomicU64 = AtomicU64::new(1);
+
 #[derive(Debug)]
 pub struct Document {
   root: SyntaxNode,
   path: Option<PathBuf>,
+  generation: u64,
 }
 
 impl Document {
@@ -138,7 +142,15 @@ impl Document {
 
     check_duplicate_keys(&tree)?;
 
-    Ok(Document { root: tree, path: None })
+    Ok(Document {
+      root: tree,
+      path: None,
+      generation: NEXT_GENERATION.fetch_add(1, Ordering::Relaxed),
+    })
+  }
+
+  pub fn generation(&self) -> u64 {
+    self.generation
   }
 
   pub fn parse_file(path: impl AsRef<Path>) -> Result<Self, YerbaError> {

data/rust/src/document/set.rs

@@ -1,7 +1,17 @@
 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 {
-  if kind == SyntaxKind::PLAIN_SCALAR && !crate::syntax::is_inline_scalar_safe(value) {
+  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);
   }
 
@@ -62,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() };
 
@@ -75,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 = scalar_replacement_text(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(), scalar_replacement_text(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> {
@@ -144,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 {