yerba 0.5.0-x86_64-linux-gnu → 0.6.0-x86_64-linux-gnu

data/rust/src/json.rs

@@ -1,11 +1,11 @@
 use crate::selector::{Selector, SelectorSegment};
 
-pub fn yaml_to_json(value: &serde_yaml::Value) -> serde_json::Value {
+pub fn yaml_to_json(value: &yaml_serde::Value) -> serde_json::Value {
   match value {
-    serde_yaml::Value::Null => serde_json::Value::Null,
-    serde_yaml::Value::Bool(boolean) => serde_json::Value::Bool(*boolean),
+    yaml_serde::Value::Null => serde_json::Value::Null,
+    yaml_serde::Value::Bool(boolean) => serde_json::Value::Bool(*boolean),
 
-    serde_yaml::Value::Number(number) => {
+    yaml_serde::Value::Number(number) => {
       if let Some(integer) = number.as_i64() {
         serde_json::Value::Number(integer.into())
       } else if let Some(float) = number.as_f64() {
@@ -15,16 +15,16 @@ pub fn yaml_to_json(value: &serde_yaml::Value) -> serde_json::Value {
       }
     }
 
-    serde_yaml::Value::String(string) => serde_json::Value::String(string.clone()),
+    yaml_serde::Value::String(string) => serde_json::Value::String(string.clone()),
 
-    serde_yaml::Value::Sequence(sequence) => serde_json::Value::Array(sequence.iter().map(yaml_to_json).collect()),
+    yaml_serde::Value::Sequence(sequence) => serde_json::Value::Array(sequence.iter().map(yaml_to_json).collect()),
 
-    serde_yaml::Value::Mapping(mapping) => {
+    yaml_serde::Value::Mapping(mapping) => {
       let mut map = serde_json::Map::new();
 
       for (key, yaml_value) in mapping {
         let json_key = match key {
-          serde_yaml::Value::String(string) => string.clone(),
+          yaml_serde::Value::String(string) => string.clone(),
           _ => format!("{:?}", key),
         };
 
@@ -34,19 +34,19 @@ pub fn yaml_to_json(value: &serde_yaml::Value) -> serde_json::Value {
       serde_json::Value::Object(map)
     }
 
-    serde_yaml::Value::Tagged(tagged) => yaml_to_json(&tagged.value),
+    yaml_serde::Value::Tagged(tagged) => yaml_to_json(&tagged.value),
   }
 }
 
-pub fn resolve_select_field(value: &serde_yaml::Value, field: &str) -> serde_json::Value {
+pub fn resolve_select_field(value: &yaml_serde::Value, field: &str) -> serde_json::Value {
   let parsed = Selector::parse(field);
   let segments = parsed.segments();
 
   if segments.len() == 1 {
     if let SelectorSegment::Key(key) = &segments[0] {
-      if let serde_yaml::Value::Mapping(map) = value {
+      if let yaml_serde::Value::Mapping(map) = value {
         for (map_key, yaml_value) in map {
-          if let serde_yaml::Value::String(key_string) = map_key {
+          if let yaml_serde::Value::String(key_string) = map_key {
             if key_string == key {
               return yaml_to_json(yaml_value);
             }
@@ -66,13 +66,13 @@ pub fn resolve_select_field(value: &serde_yaml::Value, field: &str) -> serde_jso
     for current in &current_values {
       match segment {
         SelectorSegment::AllItems => {
-          if let serde_yaml::Value::Sequence(sequence) = current {
+          if let yaml_serde::Value::Sequence(sequence) = current {
             next_values.extend(sequence.iter().cloned());
           }
         }
 
         SelectorSegment::Index(index) => {
-          if let serde_yaml::Value::Sequence(sequence) = current {
+          if let yaml_serde::Value::Sequence(sequence) = current {
             if let Some(item) = sequence.get(*index) {
               next_values.push(item.clone());
             }
@@ -80,9 +80,9 @@ pub fn resolve_select_field(value: &serde_yaml::Value, field: &str) -> serde_jso
         }
 
         SelectorSegment::Key(key) => {
-          if let serde_yaml::Value::Mapping(map) = current {
+          if let yaml_serde::Value::Mapping(map) = current {
             for (map_key, yaml_value) in map {
-              if let serde_yaml::Value::String(key_string) = map_key {
+              if let yaml_serde::Value::String(key_string) = map_key {
                 if key_string == key {
                   next_values.push(yaml_value.clone());
                 }

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};
@@ -88,10 +89,10 @@ pub fn glob_find(pattern: &str, selector: &str, condition: Option<&str>, select:
               }
             }
             None => {
-              if let serde_yaml::Value::Mapping(map) = value {
+              if let yaml_serde::Value::Mapping(map) = value {
                 for (key, yaml_value) in map {
                   let json_key = match key {
-                    serde_yaml::Value::String(string) => string.clone(),
+                    yaml_serde::Value::String(string) => string.clone(),
                     _ => format!("{:?}", key),
                   };
 

data/rust/src/selector.rs

@@ -171,6 +171,22 @@ impl Selector {
 
     result
   }
+
+  pub fn parent_path(&self) -> String {
+    let segments = self.segments();
+
+    if segments.len() <= 1 {
+      return String::new();
+    }
+
+    let parent_segments = &segments[..segments.len() - 1];
+    let parent = match self {
+      Selector::Relative(_) => Selector::Relative(parent_segments.to_vec()),
+      Selector::Absolute(_) => Selector::Absolute(parent_segments.to_vec()),
+    };
+
+    parent.to_selector_string()
+  }
 }
 
 fn parse_segments(input: &str) -> Vec<SelectorSegment> {

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),
@@ -108,70 +114,80 @@ impl<'de> Deserialize<'de> for PipelineStep {
   where
     D: serde::Deserializer<'de>,
   {
-    let mapping = serde_yaml::Mapping::deserialize(deserializer)?;
+    let mapping = yaml_serde::Mapping::deserialize(deserializer)?;
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("sort_keys".to_string())) {
-      let config: SortKeysConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("sort_keys".to_string())) {
+      let config: SortKeysConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::SortKeys(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("quote_style".to_string())) {
-      let config: QuoteStyleConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("quote_style".to_string())) {
+      let config: QuoteStyleConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::QuoteStyle(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("set".to_string())) {
-      let config: SetConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    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));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("insert".to_string())) {
-      let config: InsertConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("insert".to_string())) {
+      let config: InsertConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Insert(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("delete".to_string())) {
-      let config: DeleteConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("delete".to_string())) {
+      let config: DeleteConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Delete(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("rename".to_string())) {
-      let config: RenameConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("rename".to_string())) {
+      let config: RenameConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Rename(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("remove".to_string())) {
-      let config: RemoveConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("remove".to_string())) {
+      let config: RemoveConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Remove(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("blank_lines".to_string())) {
-      let config: BlankLinesConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("blank_lines".to_string())) {
+      let config: BlankLinesConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::BlankLines(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("directives".to_string())) {
-      let config: DirectivesConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("directives".to_string())) {
+      let config: DirectivesConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Directives(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("sort".to_string())) {
-      let config: SortConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("sort".to_string())) {
+      let config: SortConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Sort(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("unique".to_string())) {
-      let config: UniqueConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("unique".to_string())) {
+      let config: UniqueConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Unique(config));
     }
 
-    if let Some(value) = mapping.get(serde_yaml::Value::String("schema".to_string())) {
-      let config: SchemaConfig = serde_yaml::from_value(value.clone()).map_err(serde::de::Error::custom)?;
+    if let Some(value) = mapping.get(yaml_serde::Value::String("schema".to_string())) {
+      let config: SchemaConfig = yaml_serde::from_value(value.clone()).map_err(serde::de::Error::custom)?;
       return Ok(PipelineStep::Schema(config));
     }
 
     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 +208,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,
@@ -229,7 +259,7 @@ pub struct RuleResult {
 impl Yerbafile {
   pub fn load(path: impl AsRef<Path>) -> Result<Self, YerbaError> {
     let content = fs::read_to_string(path.as_ref())?;
-    let mut yerbafile: Yerbafile = serde_yaml::from_str(&content).map_err(|error| YerbaError::ParseError(format!("{}", error)))?;
+    let mut yerbafile: Yerbafile = yaml_serde::from_str(&content).map_err(|error| YerbaError::ParseError(format!("{}", error)))?;
     yerbafile.directory = path.as_ref().parent().map(|p| p.to_path_buf());
     Ok(yerbafile)
   }
@@ -293,6 +323,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,59 +342,25 @@ impl Yerbafile {
 
       let file_strings: Vec<String> = files.iter().map(|path| path.to_string_lossy().to_string()).collect();
 
-      let mut has_validation_error = false;
+      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 step in &rule.pipeline {
-        if let PipelineStep::SortKeys(config) = step {
-          let full_path = resolve_step_path(rule.path.as_deref(), config.path.as_deref());
-          let key_order: Vec<&str> = config.order.iter().map(|key| key.as_str()).collect();
-
-          let validation_results: Vec<RuleResult> = file_strings
-            .par_iter()
-            .filter_map(|file| {
-              let document = match Document::parse_file(file) {
-                Ok(document) => document,
-                Err(error) => {
-                  return Some(RuleResult {
-                    file: file.clone(),
-                    changed: false,
-                    error: Some(error),
-                  });
-                }
-              };
-
-              if let Err(error) = document.validate_sort_keys(&full_path, &key_order) {
-                Some(RuleResult {
-                  file: file.clone(),
-                  changed: false,
-                  error: Some(error),
-                })
-              } else {
-                None
-              }
-            })
-            .collect();
-
-          if !validation_results.is_empty() {
-            has_validation_error = true;
-            results.extend(validation_results);
-          }
-        }
-      }
-
-      if has_validation_error {
-        continue;
+      for result in &file_results {
+        globally_processed.insert(result.file.clone());
       }
 
-      let file_results: Vec<RuleResult> = file_strings.par_iter().map(|file| self.apply_pipeline_to_file(rule, file, write)).collect();
-
       results.extend(file_results);
     }
 
     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) => {
@@ -376,6 +373,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 {
@@ -410,6 +418,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) {
@@ -420,15 +429,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) {
@@ -451,6 +479,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) => {
@@ -470,10 +547,25 @@ 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();
 
+      document.validate_sort_keys(&full_path, &key_order)?;
       document.sort_keys(&full_path, &key_order)
     }
 

metadata

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