yerba 0.5.1-x86_64-linux-gnu → 0.6.1-x86_64-linux-gnu

data/rust/src/lib.rs

@@ -10,6 +10,7 @@ mod syntax;
 mod yaml_writer;
 pub mod yerbafile;
 
+pub use document::style::StyleEnforcement;
 pub use document::{collect_selectors, Document, DuplicateInfo, InsertPosition, LocatedNode, Location, NodeInfo, NodeType, SortField};
 pub use error::YerbaError;
 pub use quote_style::{KeyStyle, QuoteStyle};

data/rust/src/yaml_writer.rs

@@ -37,6 +37,23 @@ pub fn json_to_yaml_text(value: &Value, quote_style: &QuoteStyle, indent: usize)
         .join("\n")
     }
 
+    Value::Array(array) => {
+      let prefix = " ".repeat(indent);
+
+      array
+        .iter()
+        .map(|item| match item {
+          Value::Object(_) => {
+            let inner = json_to_yaml_text(item, quote_style, indent + 2);
+            format!("{}- {}", prefix, inner.trim_start())
+          }
+
+          _ => format!("{}- {}", prefix, format_yaml_scalar(item, quote_style)),
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+    }
+
     _ => {
       let prefix = " ".repeat(indent);
 
@@ -45,6 +62,87 @@ pub fn json_to_yaml_text(value: &Value, quote_style: &QuoteStyle, indent: usize)
   }
 }
 
+pub fn yaml_value_to_flow_text(value: &yaml_serde::Value) -> String {
+  match value {
+    yaml_serde::Value::Null => "null".to_string(),
+    yaml_serde::Value::Bool(boolean) => boolean.to_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('"', "\\\""))
+      } else {
+        string.clone()
+      }
+    }
+
+    yaml_serde::Value::Sequence(sequence) => {
+      let items: Vec<String> = sequence.iter().map(yaml_value_to_flow_text).collect();
+
+      format!("[{}]", items.join(", "))
+    }
+
+    yaml_serde::Value::Mapping(mapping) => {
+      let pairs: Vec<String> = mapping
+        .iter()
+        .map(|(key, value)| {
+          let key_string = match key {
+            yaml_serde::Value::String(string) => string.clone(),
+            _ => format!("{:?}", key),
+          };
+
+          format!("{}: {}", key_string, yaml_value_to_flow_text(value))
+        })
+        .collect();
+
+      format!("{{{}}}", pairs.join(", "))
+    }
+
+    yaml_serde::Value::Tagged(tagged) => yaml_value_to_flow_text(&tagged.value),
+  }
+}
+
+pub fn yaml_value_to_block_text(value: &yaml_serde::Value, indent: usize) -> String {
+  let prefix = " ".repeat(indent);
+
+  match value {
+    yaml_serde::Value::Sequence(sequence) => sequence
+      .iter()
+      .map(|item| match item {
+        yaml_serde::Value::Mapping(_) => {
+          let inner = yaml_value_to_block_text(item, indent + 2);
+          format!("{}- {}", prefix, inner.trim_start())
+        }
+
+        _ => format!("{}- {}", prefix, yaml_value_to_flow_text(item)),
+      })
+      .collect::<Vec<_>>()
+      .join("\n"),
+
+    yaml_serde::Value::Mapping(mapping) => mapping
+      .iter()
+      .map(|(key, value)| {
+        let key_string = match key {
+          yaml_serde::Value::String(string) => string.clone(),
+          _ => format!("{:?}", key),
+        };
+        match value {
+          yaml_serde::Value::Sequence(_) | yaml_serde::Value::Mapping(_) => {
+            let inner = yaml_value_to_block_text(value, indent + 2);
+
+            format!("{}{}:\n{}", prefix, key_string, inner)
+          }
+
+          _ => format!("{}{}: {}", prefix, key_string, yaml_value_to_flow_text(value)),
+        }
+      })
+      .collect::<Vec<_>>()
+      .join("\n"),
+
+    _ => format!("{}{}", prefix, yaml_value_to_flow_text(value)),
+  }
+}
+
 fn format_yaml_scalar(value: &Value, quote_style: &QuoteStyle) -> String {
   match value {
     Value::Null => "null".to_string(),

data/rust/src/yerbafile.rs

@@ -7,6 +7,10 @@ use crate::{Document, QuoteStyle, YerbaError};
 
 #[derive(Debug, Deserialize)]
 pub struct Yerbafile {
+  #[serde(default)]
+  pub files: Option<String>,
+  #[serde(default)]
+  pub pipeline: Vec<PipelineStep>,
   #[serde(default)]
   pub rules: Vec<Rule>,
   #[serde(skip)]
@@ -25,6 +29,8 @@ pub struct Rule {
 pub enum PipelineStep {
   SortKeys(SortKeysConfig),
   QuoteStyle(QuoteStyleConfig),
+  CollectionStyle(CollectionStyleConfig),
+  SequenceIndent(SequenceIndentConfig),
   Set(SetConfig),
   Insert(InsertConfig),
   Delete(DeleteConfig),
@@ -60,6 +66,8 @@ pub struct DirectivesConfig {
   pub ensure: bool,
   #[serde(default)]
   pub remove: bool,
+  #[serde(default)]
+  pub max: Option<usize>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -120,6 +128,16 @@ impl<'de> Deserialize<'de> for PipelineStep {
       return Ok(PipelineStep::QuoteStyle(config));
     }
 
+    if let Some(value) = mapping.get(yaml_serde::Value::String("collection_style".to_string())) {
+      let config: CollectionStyleConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+      return Ok(PipelineStep::CollectionStyle(config));
+    }
+
+    if let Some(value) = mapping.get(yaml_serde::Value::String("sequence_indent".to_string())) {
+      let config: SequenceIndentConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+      return Ok(PipelineStep::SequenceIndent(config));
+    }
+
     if let Some(value) = mapping.get(yaml_serde::Value::String("set".to_string())) {
       let config: SetConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Set(config));
@@ -171,7 +189,7 @@ impl<'de> Deserialize<'de> for PipelineStep {
     }
 
     Err(serde::de::Error::custom(
-      "unknown pipeline step: expected sort_keys, quote_style, set, insert, delete, rename, remove, blank_lines, sort, directives, unique, or schema",
+      "unknown pipeline step: expected sort_keys, quote_style, collection_style, sequence_indent, set, insert, delete, rename, remove, blank_lines, sort, directives, unique, or schema",
     ))
   }
 }
@@ -192,6 +210,20 @@ pub struct QuoteStyleConfig {
   pub path: Option<String>,
 }
 
+#[derive(Debug, Clone, Deserialize)]
+pub struct CollectionStyleConfig {
+  pub style: String,
+  #[serde(default)]
+  pub path: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct SequenceIndentConfig {
+  pub style: String,
+  #[serde(default)]
+  pub path: Option<String>,
+}
+
 #[derive(Debug, Clone, Deserialize)]
 pub struct SetConfig {
   pub path: String,
@@ -293,6 +325,7 @@ impl Yerbafile {
 
   pub fn apply(&self, write: bool) -> Vec<RuleResult> {
     let mut results = Vec::new();
+    let mut globally_processed: std::collections::HashSet<String> = std::collections::HashSet::new();
 
     for rule in &self.rules {
       let files = match glob::glob(&rule.files) {
@@ -311,7 +344,17 @@ impl Yerbafile {
 
       let file_strings: Vec<String> = files.iter().map(|path| path.to_string_lossy().to_string()).collect();
 
-      let file_results: Vec<RuleResult> = file_strings.par_iter().map(|file| self.apply_pipeline_to_file(rule, file, write)).collect();
+      let file_results: Vec<RuleResult> = file_strings
+        .par_iter()
+        .map(|file| {
+          let run_global = !globally_processed.contains(file.as_str()) && self.should_run_global_pipeline(file);
+          self.apply_pipeline_to_file(rule, file, write, run_global)
+        })
+        .collect();
+
+      for result in &file_results {
+        globally_processed.insert(result.file.clone());
+      }
 
       results.extend(file_results);
     }
@@ -319,7 +362,7 @@ impl Yerbafile {
     results
   }
 
-  fn apply_pipeline_to_file(&self, rule: &Rule, file: &str, write: bool) -> RuleResult {
+  fn apply_pipeline_to_file(&self, rule: &Rule, file: &str, write: bool, run_global: bool) -> RuleResult {
     let mut document = match Document::parse_file(file) {
       Ok(document) => document,
       Err(error) => {
@@ -332,6 +375,17 @@ impl Yerbafile {
     };
 
     let original = document.to_string();
+
+    if run_global {
+      if let Err(error) = execute_pipeline(&mut document, &self.pipeline, None, file, self) {
+        return RuleResult {
+          file: file.to_string(),
+          changed: false,
+          error: Some(error),
+        };
+      }
+    }
+
     let base_path = rule.path.as_deref();
 
     for step in &rule.pipeline {
@@ -366,6 +420,7 @@ impl Yerbafile {
 
   pub fn apply_file(&self, file: &str, write: bool) -> Vec<RuleResult> {
     let mut results = Vec::new();
+    let mut ran_global = false;
 
     for rule in &self.rules {
       if let Ok(pattern) = glob::Pattern::new(&rule.files) {
@@ -376,15 +431,34 @@ impl Yerbafile {
         continue;
       }
 
-      results.push(self.apply_pipeline_to_file(rule, file, write));
+      let run_global = !ran_global && self.should_run_global_pipeline(file);
+      results.push(self.apply_pipeline_to_file(rule, file, write, run_global));
+      ran_global = true;
     }
 
     results
   }
 
+  fn should_run_global_pipeline(&self, file_path: &str) -> bool {
+    if self.pipeline.is_empty() {
+      return false;
+    }
+
+    match &self.files {
+      Some(glob_pattern) => glob::Pattern::new(glob_pattern)
+        .map(|pattern| pattern.matches(file_path) || pattern.matches_path(Path::new(file_path)))
+        .unwrap_or(false),
+      None => true,
+    }
+  }
+
   pub fn apply_to_document(&self, document: &mut Document, file_path: &str) -> Result<bool, YerbaError> {
     let original = document.to_string();
 
+    if self.should_run_global_pipeline(file_path) {
+      execute_pipeline(document, &self.pipeline, None, file_path, self)?;
+    }
+
     for rule in &self.rules {
       if !file_path.is_empty() {
         if let Ok(pattern) = glob::Pattern::new(&rule.files) {
@@ -407,6 +481,55 @@ impl Yerbafile {
   }
 }
 
+fn execute_pipeline(document: &mut Document, steps: &[PipelineStep], base_path: Option<&str>, file: &str, yerbafile: &Yerbafile) -> Result<(), YerbaError> {
+  use crate::document::style::StyleEnforcement;
+
+  let mut enforcement = StyleEnforcement {
+    collection_style: None,
+    sequence_indent: None,
+    key_style: None,
+    value_style: None,
+  };
+
+  let mut has_enforcement = false;
+  let mut remaining_steps: Vec<&PipelineStep> = Vec::new();
+
+  for step in steps {
+    match step {
+      PipelineStep::CollectionStyle(config) if config.path.is_none() && base_path.is_none() => {
+        enforcement.collection_style = Some(config.style.clone());
+        has_enforcement = true;
+      }
+
+      PipelineStep::SequenceIndent(config) if config.path.is_none() && base_path.is_none() => {
+        enforcement.sequence_indent = Some(config.style.clone());
+        has_enforcement = true;
+      }
+
+      PipelineStep::QuoteStyle(config) if config.path.is_none() && base_path.is_none() => {
+        let key_style = config.key_style.parse::<crate::KeyStyle>().ok();
+        let value_style = config.value_style.parse::<QuoteStyle>().ok();
+
+        enforcement.key_style = key_style;
+        enforcement.value_style = value_style;
+        has_enforcement = true;
+      }
+
+      _ => remaining_steps.push(step),
+    }
+  }
+
+  if has_enforcement {
+    document.enforce_styles(&enforcement)?;
+  }
+
+  for step in remaining_steps {
+    execute_step(document, step, base_path, file, yerbafile)?;
+  }
+
+  Ok(())
+}
+
 fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<&str>, _file: &str, yerbafile: &Yerbafile) -> Result<(), YerbaError> {
   match step {
     PipelineStep::QuoteStyle(config) => {
@@ -426,6 +549,20 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
       Ok(())
     }
 
+    PipelineStep::CollectionStyle(config) => {
+      let dot_path = resolve_step_path(base_path, config.path.as_deref());
+      let path = if dot_path.is_empty() { None } else { Some(dot_path.as_str()) };
+
+      document.enforce_collection_style(&config.style, path)
+    }
+
+    PipelineStep::SequenceIndent(config) => {
+      let dot_path = resolve_step_path(base_path, config.path.as_deref());
+      let path = if dot_path.is_empty() { None } else { Some(dot_path.as_str()) };
+
+      document.enforce_sequence_indent(&config.style, path)
+    }
+
     PipelineStep::SortKeys(config) => {
       let full_path = resolve_step_path(base_path, config.path.as_deref());
       let key_order: Vec<&str> = config.order.iter().map(|key| key.as_str()).collect();
@@ -540,6 +677,21 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
         return Err(YerbaError::ParseError("directives: ensure and remove are mutually exclusive".to_string()));
       }
 
+      if let Some(max) = config.max {
+        let locations = document.directive_locations();
+
+        if locations.len() > max {
+          let positions: Vec<String> = locations.iter().map(|(line, col)| format!("{}:{}", line, col)).collect();
+
+          return Err(YerbaError::ParseError(format!(
+            "found {} directive markers (---) at {}, expected at most {}",
+            locations.len(),
+            positions.join(", "),
+            max
+          )));
+        }
+      }
+
       if config.ensure {
         document.ensure_directives()
       } else if config.remove {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.1
 platform: x86_64-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-05-19 00:00:00.000000000 Z
+date: 2026-06-19 00:00:00.000000000 Z
 dependencies: []
 description: A CLI tool for editing YAML while preserving structure, comments, and
   format.