yerba 0.3.0-arm-linux-gnu → 0.4.1-arm-linux-gnu

data/rust/src/json.rs

@@ -117,12 +117,6 @@ pub fn select_field_key(field: &str) -> String {
   parsed
     .segments()
     .iter()
-    .find_map(|segment| {
-      if let SelectorSegment::Key(key) = segment {
-        Some(key.clone())
-      } else {
-        None
-      }
-    })
+    .find_map(|segment| if let SelectorSegment::Key(key) = segment { Some(key.clone()) } else { None })
     .unwrap_or_else(|| field.to_string())
 }

data/rust/src/lib.rs

@@ -9,9 +9,9 @@ mod syntax;
 mod yaml_writer;
 pub mod yerbafile;
 
-pub use document::{collect_selectors, Document, InsertPosition, SortField};
+pub use document::{collect_selectors, Document, InsertPosition, Location, NodeInfo, NodeType, SortField};
 pub use error::YerbaError;
-pub use quote_style::QuoteStyle;
+pub use quote_style::{KeyStyle, QuoteStyle};
 pub use selector::Selector;
 pub use syntax::{detect_yaml_type, ScalarValue, YerbaValueType};
 pub use yaml_writer::json_to_yaml_text;
@@ -28,3 +28,89 @@ pub fn parse(source: &str) -> Result<Document, YerbaError> {
 pub fn parse_file(path: impl AsRef<std::path::Path>) -> Result<Document, YerbaError> {
   Document::parse_file(path)
 }
+
+pub fn glob_get(pattern: &str, selector: &str) -> Vec<ScalarValue> {
+  use rayon::prelude::*;
+
+  let parsed_selector = Selector::parse(selector);
+
+  let files = match glob::glob(pattern) {
+    Ok(paths) => paths.filter_map(|p| p.ok()).collect::<Vec<_>>(),
+    Err(_) => return vec![],
+  };
+
+  files
+    .par_iter()
+    .flat_map(|file| {
+      let mut results = Vec::new();
+
+      if let Ok(document) = Document::parse_file(file) {
+        if parsed_selector.has_wildcard() {
+          results.extend(document.get_all_typed(selector));
+        } else if let Some(scalar) = document.get_typed(selector) {
+          results.push(scalar);
+        }
+      }
+
+      results
+    })
+    .collect()
+}
+
+pub fn glob_find(pattern: &str, selector: &str, condition: Option<&str>, select: Option<&str>) -> Vec<serde_json::Value> {
+  use rayon::prelude::*;
+
+  let files = match glob::glob(pattern) {
+    Ok(paths) => paths.filter_map(|p| p.ok()).collect::<Vec<_>>(),
+    Err(_) => return vec![],
+  };
+
+  let select_fields: Option<Vec<&str>> = select.map(|s| s.split(',').collect());
+
+  files
+    .par_iter()
+    .flat_map(|file| {
+      let mut file_results = Vec::new();
+
+      if let Ok(document) = Document::parse_file(file) {
+        let values = match condition {
+          Some(cond) => document.filter(selector, cond),
+          None => document.get_values(selector),
+        };
+
+        let file_string = file.to_string_lossy().to_string();
+
+        for value in &values {
+          let mut result = serde_json::Map::new();
+          result.insert("__file".to_string(), serde_json::Value::String(file_string.clone()));
+
+          match &select_fields {
+            Some(fields) => {
+              for field in fields {
+                let json_value = json::resolve_select_field(value, field);
+                let json_key = json::select_field_key(field);
+                result.insert(json_key, json_value);
+              }
+            }
+            None => {
+              if let serde_yaml::Value::Mapping(map) = value {
+                for (key, yaml_value) in map {
+                  let json_key = match key {
+                    serde_yaml::Value::String(string) => string.clone(),
+                    _ => format!("{:?}", key),
+                  };
+
+                  result.insert(json_key, json::yaml_to_json(yaml_value));
+                }
+              }
+            }
+          }
+
+          file_results.push(serde_json::Value::Object(result));
+        }
+      }
+
+      file_results
+    })
+    .collect()
+}

data/rust/src/main.rs

@@ -31,7 +31,9 @@ static HELP: LazyLock<String> = LazyLock::new(|| {
     Yerbafile:
       yerba init           Create a new Yerbafile in the current directory
       yerba check          Check if all files match the rules (exits 1 if not)
+      yerba check <file>   Check a specific file against matching rules
       yerba apply          Apply all rules and write changes
+      yerba apply <file>   Apply rules to a specific file
 
     Examples:
       yerba get config.yml "database.host"

data/rust/src/quote_style.rs

@@ -1,29 +1,85 @@
 use clap::ValueEnum;
 use yaml_parser::SyntaxKind;
 
+#[derive(Debug, Clone, PartialEq, ValueEnum)]
+pub enum KeyStyle {
+  /// Unquoted key (host:)
+  Plain,
+  /// Single-quoted key ('host':)
+  Single,
+  /// Double-quoted key ("host":)
+  Double,
+}
+
+impl std::str::FromStr for KeyStyle {
+  type Err = String;
+
+  fn from_str(string: &str) -> Result<Self, Self::Err> {
+    match string {
+      "plain" => Ok(KeyStyle::Plain),
+      "single" | "single-quoted" => Ok(KeyStyle::Single),
+      "double" | "double-quoted" => Ok(KeyStyle::Double),
+      _ => Err(format!("unknown key style: '{}'. Valid options: plain, single, double", string)),
+    }
+  }
+}
+
+impl KeyStyle {
+  pub(crate) fn to_syntax_kind(&self) -> SyntaxKind {
+    match self {
+      KeyStyle::Plain => SyntaxKind::PLAIN_SCALAR,
+      KeyStyle::Single => SyntaxKind::SINGLE_QUOTED_SCALAR,
+      KeyStyle::Double => SyntaxKind::DOUBLE_QUOTED_SCALAR,
+    }
+  }
+}
+
 #[derive(Debug, Clone, PartialEq, ValueEnum)]
 pub enum QuoteStyle {
+  /// Unquoted value (host: localhost)
   Plain,
+  /// Single-quoted value (host: 'localhost')
   #[value(alias = "single-quoted")]
   Single,
+  /// Double-quoted value (host: "localhost")
   #[value(alias = "double-quoted")]
   Double,
-  #[value(alias = "block-literal")]
+  /// Literal block scalar, strip trailing newline (|-)
+  #[value(alias = "block-literal", alias = "|-")]
   Literal,
-  #[value(alias = "block-folded")]
+  /// Literal block scalar, keep one trailing newline (|)
+  #[value(alias = "|")]
+  LiteralClip,
+  /// Literal block scalar, keep all trailing newlines (|+)
+  #[value(alias = "|+")]
+  LiteralKeep,
+  /// Folded block scalar, strip trailing newline (>-)
+  #[value(alias = "block-folded", alias = ">-")]
   Folded,
+  /// Folded block scalar, keep one trailing newline (>)
+  #[value(alias = ">")]
+  FoldedClip,
+  /// Folded block scalar, keep all trailing newlines (>+)
+  #[value(alias = ">+")]
+  FoldedKeep,
 }
 
 impl std::str::FromStr for QuoteStyle {
   type Err = String;
 
   fn from_str(string: &str) -> Result<Self, Self::Err> {
-    match string {
+    let normalized = string.replace('_', "-");
+
+    match normalized.as_str() {
       "plain" => Ok(QuoteStyle::Plain),
       "single" | "single-quoted" => Ok(QuoteStyle::Single),
       "double" | "double-quoted" => Ok(QuoteStyle::Double),
-      "literal" | "block-literal" => Ok(QuoteStyle::Literal),
-      "folded" | "block-folded" => Ok(QuoteStyle::Folded),
+      "literal" | "block-literal" | "|-" => Ok(QuoteStyle::Literal),
+      "literal-clip" | "|" => Ok(QuoteStyle::LiteralClip),
+      "literal-keep" | "|+" => Ok(QuoteStyle::LiteralKeep),
+      "folded" | "block-folded" | ">-" => Ok(QuoteStyle::Folded),
+      "folded-clip" | ">" => Ok(QuoteStyle::FoldedClip),
+      "folded-keep" | ">+" => Ok(QuoteStyle::FoldedKeep),
       _ => Err(format!("unknown quote style: '{}'", string)),
     }
   }
@@ -35,8 +91,28 @@ impl QuoteStyle {
       QuoteStyle::Plain => SyntaxKind::PLAIN_SCALAR,
       QuoteStyle::Single => SyntaxKind::SINGLE_QUOTED_SCALAR,
       QuoteStyle::Double => SyntaxKind::DOUBLE_QUOTED_SCALAR,
-      QuoteStyle::Literal => SyntaxKind::BLOCK_SCALAR_TEXT,
-      QuoteStyle::Folded => SyntaxKind::BLOCK_SCALAR_TEXT,
+      QuoteStyle::Literal | QuoteStyle::LiteralClip | QuoteStyle::LiteralKeep | QuoteStyle::Folded | QuoteStyle::FoldedClip | QuoteStyle::FoldedKeep => {
+        SyntaxKind::BLOCK_SCALAR_TEXT
+      }
+    }
+  }
+
+  pub(crate) fn is_block_scalar(&self) -> bool {
+    matches!(
+      self,
+      QuoteStyle::Literal | QuoteStyle::LiteralClip | QuoteStyle::LiteralKeep | QuoteStyle::Folded | QuoteStyle::FoldedClip | QuoteStyle::FoldedKeep
+    )
+  }
+
+  pub(crate) fn block_header(&self) -> &'static str {
+    match self {
+      QuoteStyle::Literal => "|-",
+      QuoteStyle::LiteralClip => "|",
+      QuoteStyle::LiteralKeep => "|+",
+      QuoteStyle::Folded => ">-",
+      QuoteStyle::FoldedClip => ">",
+      QuoteStyle::FoldedKeep => ">+",
+      _ => "",
     }
   }
 }

data/rust/src/selector.rs

@@ -58,10 +58,7 @@ impl Selector {
   }
 
   pub fn ends_with_bracket(&self) -> bool {
-    matches!(
-      self.segments().last(),
-      Some(SelectorSegment::AllItems | SelectorSegment::Index(_))
-    )
+    matches!(self.segments().last(), Some(SelectorSegment::AllItems | SelectorSegment::Index(_)))
   }
 
   pub fn has_brackets(&self) -> bool {
@@ -109,9 +106,7 @@ impl Selector {
   pub fn split_at_first_bracket(&self) -> (Selector, Selector) {
     let segments = self.segments();
 
-    let first_bracket = segments
-      .iter()
-      .position(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_)));
+    let first_bracket = segments.iter().position(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_)));
 
     match first_bracket {
       Some(position) => {

data/rust/src/syntax.rs

@@ -47,16 +47,11 @@ pub fn extract_scalar(node: &SyntaxNode) -> Option<ScalarValue> {
     _ => return None,
   };
 
-  Some(ScalarValue {
-    text,
-    kind: token.kind(),
-  })
+  Some(ScalarValue { text, kind: token.kind() })
 }
 
 pub fn is_map_key(token: &SyntaxToken) -> bool {
-  token
-    .parent_ancestors()
-    .any(|ancestor| ancestor.kind() == SyntaxKind::BLOCK_MAP_KEY)
+  token.parent_ancestors().any(|ancestor| ancestor.kind() == SyntaxKind::BLOCK_MAP_KEY)
 }
 
 pub fn find_entry_by_key(map: &BlockMap, key: &str) -> Option<BlockMapEntry> {
@@ -70,15 +65,12 @@ pub fn find_entry_by_key(map: &BlockMap, key: &str) -> Option<BlockMapEntry> {
 }
 
 pub fn find_scalar_token(node: &SyntaxNode) -> Option<SyntaxToken> {
-  node
-    .descendants_with_tokens()
-    .filter_map(|element| element.into_token())
-    .find(|token| {
-      matches!(
-        token.kind(),
-        SyntaxKind::PLAIN_SCALAR | SyntaxKind::DOUBLE_QUOTED_SCALAR | SyntaxKind::SINGLE_QUOTED_SCALAR
-      )
-    })
+  node.descendants_with_tokens().filter_map(|element| element.into_token()).find(|token| {
+    matches!(
+      token.kind(),
+      SyntaxKind::PLAIN_SCALAR | SyntaxKind::DOUBLE_QUOTED_SCALAR | SyntaxKind::SINGLE_QUOTED_SCALAR
+    )
+  })
 }
 
 pub fn format_scalar_value(value: &str, kind: SyntaxKind) -> String {
@@ -122,7 +114,38 @@ pub fn extract_scalar_text(node: &SyntaxNode) -> Option<String> {
 }
 
 pub fn unescape_double_quoted(text: &str) -> String {
-  text.replace("\\\"", "\"").replace("\\\\", "\\")
+  let mut result = String::with_capacity(text.len());
+  let mut chars = text.chars();
+
+  while let Some(character) = chars.next() {
+    if character == '\\' {
+      match chars.next() {
+        Some('n') => result.push('\n'),
+        Some('t') => result.push('\t'),
+        Some('r') => result.push('\r'),
+        Some('\\') => result.push('\\'),
+        Some('"') => result.push('"'),
+        Some('/') => result.push('/'),
+        Some('0') => result.push('\0'),
+        Some('a') => result.push('\u{07}'),
+        Some('b') => result.push('\u{08}'),
+        Some('e') => result.push('\u{1b}'),
+        Some('v') => result.push('\u{0b}'),
+        Some(' ') => result.push(' '),
+        Some('_') => result.push('\u{a0}'),
+        Some('\n') => {} // line continuation: skip newline and leading whitespace
+        Some(other) => {
+          result.push('\\');
+          result.push(other);
+        }
+        None => result.push('\\'),
+      }
+    } else {
+      result.push(character);
+    }
+  }
+
+  result
 }
 
 pub fn unescape_single_quoted(text: &str) -> String {
@@ -194,10 +217,7 @@ pub fn is_yaml_non_string(value: &str) -> bool {
 }
 
 pub fn is_yaml_truthy(value: &str) -> bool {
-  matches!(
-    value,
-    "true" | "True" | "TRUE" | "yes" | "Yes" | "YES" | "on" | "On" | "ON" | "y" | "Y"
-  )
+  matches!(value, "true" | "True" | "TRUE" | "yes" | "Yes" | "YES" | "on" | "On" | "ON" | "y" | "Y")
 }
 
 pub fn detect_yaml_type_from_plain(value: &str) -> YerbaValueType {

data/rust/src/yerbafile.rs

@@ -30,6 +30,7 @@ pub enum PipelineStep {
   Remove(RemoveConfig),
   BlankLines(BlankLinesConfig),
   Sort(SortConfig),
+  Directives(DirectivesConfig),
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -49,6 +50,14 @@ pub struct BlankLinesConfig {
   pub count: usize,
 }
 
+#[derive(Debug, Clone, Deserialize)]
+pub struct DirectivesConfig {
+  #[serde(default)]
+  pub ensure: bool,
+  #[serde(default)]
+  pub remove: bool,
+}
+
 #[derive(Debug, Clone, Deserialize)]
 pub struct RenameConfig {
   pub from: String,
@@ -112,13 +121,18 @@ impl<'de> Deserialize<'de> for PipelineStep {
       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)?;
+      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)?;
       return Ok(PipelineStep::Sort(config));
     }
 
     Err(serde::de::Error::custom(
-      "unknown pipeline step: expected sort_keys, quote_style, set, insert, delete, rename, remove, blank_lines, or sort",
+      "unknown pipeline step: expected sort_keys, quote_style, set, insert, delete, rename, remove, blank_lines, sort, or directives",
     ))
   }
 }
@@ -176,15 +190,18 @@ 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 yerbafile: Yerbafile =
-      serde_yaml::from_str(&content).map_err(|error| YerbaError::ParseError(format!("{}", error)))?;
+    let yerbafile: Yerbafile = serde_yaml::from_str(&content).map_err(|error| YerbaError::ParseError(format!("{}", error)))?;
     Ok(yerbafile)
   }
 
   pub fn find() -> Option<PathBuf> {
+    Self::find_from(std::env::current_dir().ok()?)
+  }
+
+  pub fn find_from(start: impl AsRef<Path>) -> Option<PathBuf> {
     let candidates = ["Yerbafile", "Yerbafile.yml", "Yerbafile.yaml", ".yerbafile"];
 
-    let mut directory = std::env::current_dir().ok()?;
+    let mut directory = start.as_ref().to_path_buf();
 
     loop {
       for candidate in &candidates {
@@ -291,10 +308,7 @@ impl Yerbafile {
         continue;
       }
 
-      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| self.apply_pipeline_to_file(rule, file, write)).collect();
 
       results.extend(file_results);
     }
@@ -346,6 +360,48 @@ impl Yerbafile {
       error: None,
     }
   }
+
+  pub fn apply_file(&self, file: &str, write: bool) -> Vec<RuleResult> {
+    let mut results = Vec::new();
+
+    for rule in &self.rules {
+      if let Ok(pattern) = glob::Pattern::new(&rule.files) {
+        if !pattern.matches(file) && !pattern.matches_path(Path::new(file)) {
+          continue;
+        }
+      } else {
+        continue;
+      }
+
+      results.push(self.apply_pipeline_to_file(rule, file, write));
+    }
+
+    results
+  }
+
+  pub fn apply_to_document(&self, document: &mut Document, file_path: &str) -> Result<bool, YerbaError> {
+    let original = document.to_string();
+
+    for rule in &self.rules {
+      if !file_path.is_empty() {
+        if let Ok(pattern) = glob::Pattern::new(&rule.files) {
+          if !pattern.matches(file_path) && !pattern.matches_path(Path::new(file_path)) {
+            continue;
+          }
+        } else {
+          continue;
+        }
+      }
+
+      let base_path = rule.path.as_deref();
+
+      for step in &rule.pipeline {
+        execute_step(document, step, base_path)?;
+      }
+    }
+
+    Ok(document.to_string() != original)
+  }
 }
 
 fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<&str>) -> Result<(), YerbaError> {
@@ -353,15 +409,16 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
     PipelineStep::QuoteStyle(config) => {
       let dot_path = config.path.as_deref();
 
-      let key_style = config.key_style.parse::<QuoteStyle>().map_err(YerbaError::ParseError)?;
+      let key_style = config.key_style.parse::<crate::KeyStyle>().map_err(YerbaError::ParseError)?;
 
-      let value_style = config
-        .value_style
-        .parse::<QuoteStyle>()
-        .map_err(YerbaError::ParseError)?;
+      let value_style = config.value_style.parse::<QuoteStyle>().map_err(YerbaError::ParseError)?;
 
       document.enforce_key_style(&key_style, dot_path)?;
-      document.enforce_quotes_at(&value_style, dot_path)?;
+      let warnings = document.enforce_quotes_at(&value_style, dot_path)?;
+
+      for warning in &warnings {
+        eprintln!("  warning: {}", warning);
+      }
 
       Ok(())
     }
@@ -451,14 +508,24 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_path: Option<
 
     PipelineStep::Sort(config) => {
       let full_path = resolve_step_path(base_path, config.path.as_deref());
-      let sort_fields = config
-        .by
-        .as_deref()
-        .map(crate::SortField::parse_list)
-        .unwrap_or_default();
+      let sort_fields = config.by.as_deref().map(crate::SortField::parse_list).unwrap_or_default();
 
       document.sort_items(&full_path, &sort_fields, config.case_sensitive)
     }
+
+    PipelineStep::Directives(config) => {
+      if config.ensure && config.remove {
+        return Err(YerbaError::ParseError("directives: ensure and remove are mutually exclusive".to_string()));
+      }
+
+      if config.ensure {
+        document.ensure_directives()
+      } else if config.remove {
+        document.remove_directives()
+      } else {
+        Ok(())
+      }
+    }
   }
 }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: arm-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-05-04 00:00:00.000000000 Z
+date: 2026-05-05 00:00:00.000000000 Z
 dependencies: []
 description: A CLI tool for editing YAML while preserving structure, comments, and
   format.
@@ -36,9 +36,11 @@ files:
 - lib/yerba/formatting.rb
 - lib/yerba/location.rb
 - lib/yerba/map.rb
+- lib/yerba/query_result.rb
 - lib/yerba/scalar.rb
 - lib/yerba/sequence.rb
 - lib/yerba/version.rb
+- lib/yerba/yerbafile.rb
 - rust/Cargo.lock
 - rust/Cargo.toml
 - rust/build.rs
@@ -48,6 +50,7 @@ files:
 - rust/src/commands/blank_lines.rs
 - rust/src/commands/check.rs
 - rust/src/commands/delete.rs
+- rust/src/commands/directives.rs
 - rust/src/commands/get.rs
 - rust/src/commands/init.rs
 - rust/src/commands/insert.rs
@@ -64,7 +67,14 @@ files:
 - rust/src/commands/sort_keys.rs
 - rust/src/commands/version.rs
 - rust/src/didyoumean.rs
-- rust/src/document.rs
+- rust/src/document/condition.rs
+- rust/src/document/delete.rs
+- rust/src/document/get.rs
+- rust/src/document/insert.rs
+- rust/src/document/mod.rs
+- rust/src/document/set.rs
+- rust/src/document/sort.rs
+- rust/src/document/style.rs
 - rust/src/error.rs
 - rust/src/ffi.rs
 - rust/src/json.rs