yerba 0.4.2-aarch64-linux-gnu → 0.5.1-aarch64-linux-gnu

data/rust/src/schema.rs

@@ -0,0 +1,93 @@
+use std::fs;
+use std::path::Path;
+
+use crate::error::YerbaError;
+
+#[derive(Debug)]
+pub struct ValidationError {
+  pub path: String,
+  pub message: String,
+  pub item_label: Option<String>,
+  pub line: Option<usize>,
+}
+
+impl std::fmt::Display for ValidationError {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    let location = match self.line {
+      Some(line) => format!(" (line {})", line),
+      None => String::new(),
+    };
+
+    match &self.item_label {
+      Some(label) => write!(f, "{} at {} ({}){}", self.message, self.path, label, location),
+      None => write!(f, "{} at {}{}", self.message, self.path, location),
+    }
+  }
+}
+
+pub fn validate_value(value: &serde_json::Value, schema: &serde_json::Value) -> Vec<ValidationError> {
+  let compiled = match jsonschema::draft7::new(schema) {
+    Ok(compiled) => compiled,
+    Err(error) => {
+      return vec![ValidationError {
+        path: String::new(),
+        message: format!("invalid schema: {}", error),
+        item_label: None,
+        line: None,
+      }];
+    }
+  };
+
+  compiled
+    .iter_errors(value)
+    .map(|error| ValidationError {
+      path: error.instance_path.to_string(),
+      message: error.to_string(),
+      item_label: None,
+      line: None,
+    })
+    .collect()
+}
+
+pub fn validate_array(items: &[serde_json::Value], schema: &serde_json::Value) -> Vec<ValidationError> {
+  let compiled = match jsonschema::draft7::new(schema) {
+    Ok(compiled) => compiled,
+    Err(error) => {
+      return vec![ValidationError {
+        path: String::new(),
+        message: format!("invalid schema: {}", error),
+        item_label: None,
+        line: None,
+      }];
+    }
+  };
+
+  let mut errors = Vec::new();
+
+  for (index, item) in items.iter().enumerate() {
+    let item_label = item
+      .get("name")
+      .or_else(|| item.get("title"))
+      .or_else(|| item.get("id"))
+      .and_then(|value| value.as_str())
+      .map(|string| string.to_string())
+      .unwrap_or_else(|| format!("index {}", index));
+
+    for error in compiled.iter_errors(item) {
+      errors.push(ValidationError {
+        path: format!("/{}{}", index, error.instance_path),
+        message: error.to_string(),
+        item_label: Some(item_label.clone()),
+        line: None,
+      });
+    }
+  }
+
+  errors
+}
+
+pub fn load_schema(path: impl AsRef<Path>) -> Result<serde_json::Value, YerbaError> {
+  let content = fs::read_to_string(path.as_ref())?;
+
+  serde_json::from_str(&content).map_err(|error| YerbaError::ParseError(format!("invalid JSON schema: {}", error)))
+}

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/syntax.rs

@@ -8,6 +8,9 @@ use yaml_parser::{SyntaxKind, SyntaxNode, SyntaxToken};
 pub struct ScalarValue {
   pub text: String,
   pub kind: SyntaxKind,
+  pub file_path: Option<String>,
+  pub selector: Option<String>,
+  pub line: Option<usize>,
 }
 
 #[repr(C)]
@@ -29,25 +32,44 @@ pub fn detect_yaml_type(scalar: &ScalarValue) -> YerbaValueType {
 }
 
 pub fn extract_scalar(node: &SyntaxNode) -> Option<ScalarValue> {
-  let token = find_scalar_token(node)?;
+  if let Some(token) = find_scalar_token(node) {
+    let text = match token.kind() {
+      SyntaxKind::PLAIN_SCALAR => token.text().to_string(),
 
-  let text = match token.kind() {
-    SyntaxKind::PLAIN_SCALAR => token.text().to_string(),
+      SyntaxKind::DOUBLE_QUOTED_SCALAR => {
+        let raw = token.text();
+        unescape_double_quoted(&raw[1..raw.len() - 1])
+      }
 
-    SyntaxKind::DOUBLE_QUOTED_SCALAR => {
-      let raw = token.text();
-      unescape_double_quoted(&raw[1..raw.len() - 1])
-    }
+      SyntaxKind::SINGLE_QUOTED_SCALAR => {
+        let raw = token.text();
+        unescape_single_quoted(&raw[1..raw.len() - 1])
+      }
 
-    SyntaxKind::SINGLE_QUOTED_SCALAR => {
-      let raw = token.text();
-      unescape_single_quoted(&raw[1..raw.len() - 1])
-    }
+      _ => return None,
+    };
 
-    _ => return None,
-  };
+    return Some(ScalarValue {
+      text,
+      kind: token.kind(),
+      file_path: None,
+      selector: None,
+      line: None,
+    });
+  }
 
-  Some(ScalarValue { text, kind: token.kind() })
+  let block_token = node
+    .descendants_with_tokens()
+    .filter_map(|element| element.into_token())
+    .find(|token| token.kind() == SyntaxKind::BLOCK_SCALAR_TEXT)?;
+
+  Some(ScalarValue {
+    text: dedent_block_scalar(block_token.text()),
+    kind: SyntaxKind::BLOCK_SCALAR_TEXT,
+    file_path: None,
+    selector: None,
+    line: None,
+  })
 }
 
 pub fn is_map_key(token: &SyntaxToken) -> bool {
@@ -89,28 +111,61 @@ pub fn format_scalar_value(value: &str, kind: SyntaxKind) -> String {
   }
 }
 
-pub fn extract_scalar_text(node: &SyntaxNode) -> Option<String> {
-  let token = find_scalar_token(node)?;
+pub fn quote_if_needed(value: &str) -> String {
+  if is_yaml_non_string(value) {
+    format_scalar_value(value, SyntaxKind::DOUBLE_QUOTED_SCALAR)
+  } else {
+    value.to_string()
+  }
+}
 
-  match token.kind() {
-    SyntaxKind::PLAIN_SCALAR => Some(token.text().to_string()),
+pub fn extract_scalar_text(node: &SyntaxNode) -> Option<String> {
+  if let Some(token) = find_scalar_token(node) {
+    return match token.kind() {
+      SyntaxKind::PLAIN_SCALAR => Some(token.text().to_string()),
 
-    SyntaxKind::DOUBLE_QUOTED_SCALAR => {
-      let text = token.text();
-      let inner = &text[1..text.len() - 1];
+      SyntaxKind::DOUBLE_QUOTED_SCALAR => {
+        let text = token.text();
+        let inner = &text[1..text.len() - 1];
 
-      Some(unescape_double_quoted(inner))
-    }
+        Some(unescape_double_quoted(inner))
+      }
 
-    SyntaxKind::SINGLE_QUOTED_SCALAR => {
-      let text = token.text();
-      let inner = &text[1..text.len() - 1];
+      SyntaxKind::SINGLE_QUOTED_SCALAR => {
+        let text = token.text();
+        let inner = &text[1..text.len() - 1];
 
-      Some(unescape_single_quoted(inner))
-    }
+        Some(unescape_single_quoted(inner))
+      }
 
-    _ => None,
+      _ => None,
+    };
   }
+
+  let block_scalar_text = node
+    .descendants_with_tokens()
+    .filter_map(|element| element.into_token())
+    .find(|token| token.kind() == SyntaxKind::BLOCK_SCALAR_TEXT)?;
+
+  Some(dedent_block_scalar(block_scalar_text.text()))
+}
+
+pub fn dedent_block_scalar(text: &str) -> String {
+  let lines: Vec<&str> = text.lines().collect();
+  let min_indent = lines
+    .iter()
+    .filter(|line| !line.trim().is_empty())
+    .map(|line| line.len() - line.trim_start().len())
+    .min()
+    .unwrap_or(0);
+
+  let dedented: String = lines
+    .iter()
+    .map(|line| if line.len() >= min_indent { &line[min_indent..] } else { line.trim() })
+    .collect::<Vec<_>>()
+    .join("\n");
+
+  dedented.trim().to_string()
 }
 
 pub fn unescape_double_quoted(text: &str) -> String {
@@ -260,8 +315,13 @@ pub fn detect_yaml_type_from_plain(value: &str) -> YerbaValueType {
     return YerbaValueType::Integer;
   }
 
-  // Octal (0o...) and hex (0x...)
-  if value.starts_with("0x") || value.starts_with("0X") || value.starts_with("0o") || value.starts_with("0O") {
+  // Hex (0x...) — only valid hex digits after prefix
+  if (value.starts_with("0x") || value.starts_with("0X")) && value.len() > 2 && value[2..].chars().all(|c| c.is_ascii_hexdigit()) {
+    return YerbaValueType::Integer;
+  }
+
+  // Octal (0o...) — only valid octal digits after prefix
+  if (value.starts_with("0o") || value.starts_with("0O")) && value.len() > 2 && value[2..].chars().all(|c| matches!(c, '0'..='7')) {
     return YerbaValueType::Integer;
   }
 

data/rust/src/yerbafile.rs

@@ -9,6 +9,8 @@ use crate::{Document, QuoteStyle, YerbaError};
 pub struct Yerbafile {
   #[serde(default)]
   pub rules: Vec<Rule>,
+  #[serde(skip)]
+  pub directory: Option<PathBuf>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -31,6 +33,8 @@ pub enum PipelineStep {
   BlankLines(BlankLinesConfig),
   Sort(SortConfig),
   Directives(DirectivesConfig),
+  Unique(UniqueConfig),
+  Schema(SchemaConfig),
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -58,6 +62,31 @@ pub struct DirectivesConfig {
   pub remove: bool,
 }
 
+#[derive(Debug, Clone, Deserialize)]
+pub struct UniqueConfig {
+  #[serde(default)]
+  pub path: Option<String>,
+  #[serde(default = "default_dot")]
+  pub by: String,
+  #[serde(default)]
+  pub remove: bool,
+  #[serde(default)]
+  pub allow_blank_duplicates: bool,
+}
+
+fn default_dot() -> String {
+  ".".to_string()
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct SchemaConfig {
+  pub file: String,
+  #[serde(default)]
+  pub path: Option<String>,
+  #[serde(default)]
+  pub items: bool,
+}
+
 #[derive(Debug, Clone, Deserialize)]
 pub struct RenameConfig {
   pub from: String,
@@ -79,60 +108,70 @@ 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("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(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(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, or directives",
+      "unknown pipeline step: expected sort_keys, quote_style, set, insert, delete, rename, remove, blank_lines, sort, directives, unique, or schema",
     ))
   }
 }
@@ -184,16 +223,24 @@ fn default_key_style() -> String {
 pub struct RuleResult {
   pub file: String,
   pub changed: bool,
-  pub error: Option<String>,
+  pub error: Option<YerbaError>,
 }
 
 impl Yerbafile {
   pub fn load(path: impl AsRef<Path>) -> Result<Self, YerbaError> {
     let content = fs::read_to_string(path.as_ref())?;
-    let 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)
   }
 
+  pub fn resolve_path(&self, relative: &str) -> PathBuf {
+    match &self.directory {
+      Some(directory) => directory.join(relative),
+      None => PathBuf::from(relative),
+    }
+  }
+
   pub fn find() -> Option<PathBuf> {
     Self::find_from(std::env::current_dir().ok()?)
   }
@@ -255,7 +302,7 @@ impl Yerbafile {
           results.push(RuleResult {
             file: rule.files.clone(),
             changed: false,
-            error: Some(format!("invalid glob: {}", error)),
+            error: Some(YerbaError::ParseError(format!("invalid glob: {}", error))),
           });
 
           continue;
@@ -264,50 +311,6 @@ impl Yerbafile {
 
       let file_strings: Vec<String> = files.iter().map(|path| path.to_string_lossy().to_string()).collect();
 
-      let mut has_validation_error = false;
-
-      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(format!("{}", error)),
-                  });
-                }
-              };
-
-              if let Err(error) = document.validate_sort_keys(&full_path, &key_order) {
-                Some(RuleResult {
-                  file: file.clone(),
-                  changed: false,
-                  error: Some(format!("{}", error)),
-                })
-              } else {
-                None
-              }
-            })
-            .collect();
-
-          if !validation_results.is_empty() {
-            has_validation_error = true;
-            results.extend(validation_results);
-          }
-        }
-      }
-
-      if has_validation_error {
-        continue;
-      }
-
       let file_results: Vec<RuleResult> = file_strings.par_iter().map(|file| self.apply_pipeline_to_file(rule, file, write)).collect();
 
       results.extend(file_results);
@@ -323,7 +326,7 @@ impl Yerbafile {
         return RuleResult {
           file: file.to_string(),
           changed: false,
-          error: Some(format!("{}", error)),
+          error: Some(error),
         }
       }
     };
@@ -332,11 +335,11 @@ impl Yerbafile {
     let base_path = rule.path.as_deref();
 
     for step in &rule.pipeline {
-      if let Err(error) = execute_step(&mut document, step, base_path) {
+      if let Err(error) = execute_step(&mut document, step, base_path, file, self) {
         return RuleResult {
           file: file.to_string(),
           changed: false,
-          error: Some(format!("{}", error)),
+          error: Some(error),
         };
       }
     }
@@ -349,7 +352,7 @@ impl Yerbafile {
         return RuleResult {
           file: file.to_string(),
           changed,
-          error: Some(format!("{}", error)),
+          error: Some(YerbaError::IoError(error)),
         };
       }
     }
@@ -396,7 +399,7 @@ impl Yerbafile {
       let base_path = rule.path.as_deref();
 
       for step in &rule.pipeline {
-        execute_step(document, step, base_path)?;
+        execute_step(document, step, base_path, file_path, self)?;
       }
     }
 
@@ -404,7 +407,7 @@ impl Yerbafile {
   }
 }
 
-fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<&str>) -> Result<(), YerbaError> {
+fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<&str>, _file: &str, yerbafile: &Yerbafile) -> Result<(), YerbaError> {
   match step {
     PipelineStep::QuoteStyle(config) => {
       let dot_path = config.path.as_deref();
@@ -427,6 +430,7 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
       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)
     }
 
@@ -461,15 +465,33 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
     PipelineStep::Delete(config) => {
       let full_path = resolve_step_path(base_path, Some(&config.path));
 
-      if let Some(condition) = &config.condition {
-        let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+      if full_path.contains("[]") {
+        let concrete_selectors = document.resolve_selectors(&full_path);
 
-        if !document.evaluate_condition(parent_path, condition) {
-          return Ok(());
+        for selector in concrete_selectors.into_iter().rev() {
+          if let Some(condition) = &config.condition {
+            let parent_path = selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+
+            if !document.evaluate_condition(parent_path, condition) {
+              continue;
+            }
+          }
+
+          document.delete(&selector)?;
+        }
+
+        Ok(())
+      } else {
+        if let Some(condition) = &config.condition {
+          let parent_path = full_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+
+          if !document.evaluate_condition(parent_path, condition) {
+            return Ok(());
+          }
         }
-      }
 
-      document.delete(&full_path)
+        document.delete(&full_path)
+      }
     }
 
     PipelineStep::Rename(config) => {
@@ -526,6 +548,30 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
         Ok(())
       }
     }
+
+    PipelineStep::Schema(config) => {
+      let schema_path = yerbafile.resolve_path(&config.file);
+      let schema = crate::schema::load_schema(&schema_path)?;
+      let selector = resolve_step_path(base_path, config.path.as_deref());
+      let errors = document.validate_schema(&schema, config.items, if selector.is_empty() { None } else { Some(&selector) });
+
+      if errors.is_empty() {
+        Ok(())
+      } else {
+        Err(YerbaError::SchemaValidation(errors))
+      }
+    }
+
+    PipelineStep::Unique(config) => {
+      let full_path = resolve_step_path(base_path, config.path.as_deref());
+      let duplicates = document.unique_with_options(&full_path, &config.by, config.remove, config.allow_blank_duplicates)?;
+
+      if !duplicates.is_empty() && !config.remove {
+        return Err(YerbaError::DuplicateValues(duplicates));
+      }
+
+      Ok(())
+    }
   }
 }