yerba 0.4.0-x86_64-linux-gnu → 0.4.1-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59ee2e4bf45907cea3492eeed2eafa105586d9569984d84bd4e18b53c3705aa9
-  data.tar.gz: de41d93b4378c86a57581cfe7c3d4c2179ff3c98fc35e759f5458d8388eb302c
+  metadata.gz: 3c63edced27fb5d271865615abddb05ee8c028d4205fe01ddf1debfef105b962
+  data.tar.gz: 56f52e28f3360c7dcec764e1878b68f90b3d80c4b24ab59e15e664da3c9e848c
 SHA512:
-  metadata.gz: 3f2bc07a7c3aa8f3e66beabb9ec302b1f2d42b6ee75c399ff71970c857dcb58cda25b2f4e49c5cfe6713b002e07c47fa23f79f5f14af6e6051253e461cb8610b
-  data.tar.gz: 64ab2f256c556c820d544bfce04c145ee83988ff7b3a84f5328cb47df8cb231910de7045be9ac4adbd407e5fed65a44b7ea303b22dacf7c1cef3ad14aecc70cd
+  metadata.gz: 4b5257dcd6171cb8982c2a2839cc79faf0020bd39f740e6d4646e3c293f2b067f7effe497e7385632c35f9a55ac00edfd8eb21f3121a47b413bb350270091f55
+  data.tar.gz: 56377b990d5379a88233a2d50f39952662d295f919011f1480ae4137e85f9e1d03c5830784e9a4f088295c5f04a8e003e332c8e946bc0158f198db3594f06991

data/README.md

@@ -413,7 +413,10 @@ Use `yerba init` to create one, then `yerba apply` to apply all rules, or `yerba
 ```bash
 yerba init
 yerba apply
+yerba apply path/to/file.yml
+
 yerba check
+yerba check path/to/file.yml
 ```
 
 Each rule specifies a file glob and a list of steps to run in order:

data/ext/yerba/include/yerba.h

@@ -121,6 +121,10 @@ struct YerbaResult yerba_document_insert_object(struct Document *document,
 
 struct YerbaResult yerba_document_delete(struct Document *document, const char *path);
 
+struct YerbaResult yerba_document_insert_objects(struct Document *document,
+                                                 const char *path,
+                                                 const char *json);
+
 struct YerbaResult yerba_document_remove(struct Document *document,
                                          const char *path,
                                          const char *value);
@@ -161,6 +165,15 @@ struct YerbaResult yerba_document_blank_lines(struct Document *document,
                                               const char *path,
                                               uintptr_t count);
 
+/**
+ * Caller must free with yerba_string_free.
+ */
+char *yerba_yerbafile_find(const char *directory);
+
+struct YerbaResult yerba_document_apply_yerbafile(struct Document *document,
+                                                  const char *file_path,
+                                                  const char *yerbafile_path);
+
 char *yerba_document_to_string(const struct Document *document);
 
 void yerba_string_free(char *s);

data/ext/yerba/yerba.c

@@ -488,6 +488,17 @@ static VALUE document_insert_object(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
+/* document.insert_objects(path, array) */
+static VALUE document_insert_objects(VALUE self, VALUE path, VALUE array) {
+  struct Document *document = get_document(self);
+  VALUE json_string = rb_funcall(rb_path2class("JSON"), rb_intern("generate"), 1, array);
+
+  YerbaResult result = yerba_document_insert_objects(document, StringValueCStr(path), StringValueCStr(json_string));
+  check_result(result);
+
+  return self;
+}
+
 /* document.delete(path, condition: nil) */
 static VALUE document_delete(int argc, VALUE *argv, VALUE self) {
   VALUE path, opts;
@@ -671,6 +682,23 @@ static VALUE document_blank_lines(VALUE self, VALUE path, VALUE count) {
   return self;
 }
 
+/* document.apply_yerbafile(yerbafile_path = nil) */
+static VALUE document_apply_yerbafile(int argc, VALUE *argv, VALUE self) {
+  VALUE yerbafile_path;
+  rb_scan_args(argc, argv, "01", &yerbafile_path);
+
+  struct Document *document = get_document(self);
+  VALUE file_path = rb_iv_get(self, "@path");
+
+  const char *file_path_str = NIL_P(file_path) ? "" : StringValueCStr(file_path);
+  const char *yerbafile_path_str = NIL_P(yerbafile_path) ? NULL : StringValueCStr(yerbafile_path);
+
+  YerbaResult result = yerba_document_apply_yerbafile(document, file_path_str, yerbafile_path_str);
+  check_result(result);
+
+  return self;
+}
+
 /* document.to_s */
 static VALUE document_to_s(VALUE self) {
   struct Document *document = get_document(self);
@@ -773,6 +801,22 @@ static VALUE collection_s_find(int argc, VALUE *argv, VALUE self) {
   return rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
 }
 
+/* Yerbafile.locate(directory = nil) → path string or nil */
+static VALUE yerbafile_s_locate(int argc, VALUE *argv, VALUE klass) {
+  VALUE directory;
+  rb_scan_args(argc, argv, "01", &directory);
+
+  const char *dir = NIL_P(directory) ? NULL : StringValueCStr(directory);
+  char *result = yerba_yerbafile_find(dir);
+
+  if (!result) return Qnil;
+
+  VALUE path = make_utf8_string(result);
+  yerba_string_free(result);
+
+  return path;
+}
+
 void Init_yerba(void) {
   rb_require("json");
 
@@ -803,6 +847,7 @@ void Init_yerba(void) {
   rb_define_method(rb_cDocument, "set", document_set, -1);
   rb_define_method(rb_cDocument, "insert", document_insert, -1);
   rb_define_method(rb_cDocument, "insert_object", document_insert_object, -1);
+  rb_define_method(rb_cDocument, "insert_objects", document_insert_objects, 2);
   rb_define_method(rb_cDocument, "delete", document_delete, -1);
   rb_define_method(rb_cDocument, "remove", document_remove, 2);
   rb_define_method(rb_cDocument, "remove_at", document_remove_at, 2);
@@ -811,8 +856,12 @@ void Init_yerba(void) {
   rb_define_method(rb_cDocument, "sort_keys", document_sort_keys, 2);
   rb_define_method(rb_cDocument, "quote_style", document_quote_style, -1);
   rb_define_method(rb_cDocument, "blank_lines", document_blank_lines, 2);
+  rb_define_method(rb_cDocument, "apply_yerbafile", document_apply_yerbafile, -1);
   rb_define_method(rb_cDocument, "to_s", document_to_s, 0);
-  rb_define_method(rb_cDocument, "save!", document_save, 0);
+  rb_define_method(rb_cDocument, "write!", document_save, 0);
   rb_define_method(rb_cDocument, "changed?", document_changed_p, 0);
   rb_define_method(rb_cDocument, "path", document_path, 0);
+
+  VALUE rb_cYerbafile = rb_define_class_under(rb_mYerba, "Yerbafile", rb_cObject);
+  rb_define_singleton_method(rb_cYerbafile, "locate", yerbafile_s_locate, -1);
 }

data/lib/yerba/collection.rb

@@ -37,7 +37,7 @@ module Yerba
       each do |document|
         next unless document.sequence?
 
-        results.concat(document.root.where(...))
+        results.concat(document.root.where(...).to_a)
       end
 
       results

data/lib/yerba/document.rb

@@ -2,8 +2,10 @@
 
 module Yerba
   class Document
+    ROOT_SELECTOR = ""
+
     def root
-      self[""]
+      self[ROOT_SELECTOR]
     end
 
     def map?
@@ -15,11 +17,11 @@ module Yerba
     end
 
     def to_h
-      get_value("")
+      get_value(ROOT_SELECTOR)
     end
 
     def to_a
-      get_value("")
+      get_value(ROOT_SELECTOR)
     end
 
     def to_yaml
@@ -64,6 +66,30 @@ module Yerba
       root << item
     end
 
+    def concat(items)
+      root.concat(items)
+    end
+
+    def save!(apply: false)
+      Yerbafile.apply!(self, apply) if apply
+      write!
+
+      self
+    end
+
+    def apply!(yerbafile = nil)
+      apply(yerbafile)
+      write! if changed?
+
+      self
+    end
+
+    def apply(yerbafile = nil)
+      Yerbafile.apply!(self, yerbafile)
+
+      self
+    end
+
     def inspect
       if path
         "#<Yerba::Document path=#{path.inspect}>"

data/lib/yerba/query_result.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Yerba
+  class QueryResult
+    include Enumerable
+
+    def initialize(sequence, indices)
+      @sequence = sequence
+      @indices = indices
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      @indices.each { |index| yield @sequence[index] }
+    end
+
+    def [](position)
+      index = @indices[position]
+
+      @sequence[index] if index
+    end
+
+    def first
+      self[0]
+    end
+
+    def last
+      self[-1]
+    end
+
+    def length
+      @indices.length
+    end
+    alias size length
+    alias count length
+
+    def empty?
+      @indices.empty?
+    end
+
+    def indices
+      @indices.dup
+    end
+
+    def inspect
+      "#<Yerba::QueryResult length=#{length}>"
+    end
+  end
+end

data/lib/yerba/sequence.rb

@@ -55,6 +55,24 @@ module Yerba
       self
     end
 
+    def concat(items)
+      if @document
+        hashes = items.map do |item|
+          case item
+          when Map then item.to_hash
+          when Hash then item
+          else { value: item.to_s }
+          end
+        end
+
+        @document.insert_objects(@selector, hashes)
+      else
+        @data.concat(items)
+      end
+
+      self
+    end
+
     def each
       return enum_for(:each) unless block_given?
 
@@ -68,7 +86,7 @@ module Yerba
     end
 
     def where(selector = nil, value = nil, **criteria)
-      indices_of(selector, value, **criteria).map { |index| self[index] }
+      QueryResult.new(self, indices_of(selector, value, **criteria))
     end
 
     def pluck(*fields)

data/lib/yerba/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yerba
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/lib/yerba/yerbafile.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Yerba
+  class Yerbafile
+    attr_reader :path
+
+    def initialize(path)
+      @path = File.expand_path(path)
+
+      raise Yerba::Error, "Yerbafile not found: #{path}" unless File.exist?(@path)
+    end
+
+    def self.find(directory = Dir.pwd)
+      path = locate(directory)
+
+      path ? new(path) : nil
+    end
+
+    def self.find!(directory = Dir.pwd)
+      find(directory) || raise(Yerba::Error, "No Yerbafile found")
+    end
+
+    def self.resolve(yerbafile = nil)
+      case yerbafile
+      when Yerbafile then yerbafile
+      when String then new(yerbafile)
+      when true, nil then find!
+      end
+    end
+
+    def self.apply!(document, yerbafile = nil)
+      resolve(yerbafile).apply(document)
+    end
+
+    def apply(document)
+      document.apply_yerbafile(@path)
+
+      document
+    end
+
+    def inspect
+      "#<Yerba::Yerbafile path=#{@path.inspect}>"
+    end
+  end
+end

data/lib/yerba.rb

@@ -8,8 +8,10 @@ require_relative "yerba/formatting"
 require_relative "yerba/scalar"
 require_relative "yerba/map"
 require_relative "yerba/sequence"
+require_relative "yerba/query_result"
 require_relative "yerba/document"
 require_relative "yerba/collection"
+require_relative "yerba/yerbafile"
 
 begin
   major, minor, = RUBY_VERSION.split(".")

data/rust/Cargo.lock

@@ -472,6 +472,7 @@ version = "1.0.149"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
 dependencies = [
+ "indexmap",
  "itoa",
  "memchr",
  "serde",
@@ -784,7 +785,7 @@ dependencies = [
 
 [[package]]
 name = "yerba"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "cbindgen",
  "clap",
@@ -795,6 +796,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_yaml",
+ "tempfile",
  "yaml_parser",
 ]
 

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"
@@ -25,7 +25,7 @@ rowan = "0.16"
 glob = "0.3"
 serde = { version = "1", features = ["derive"] }
 serde_yaml = "0.9"
-serde_json = "1"
+serde_json = { version = "1", features = ["preserve_order"] }
 clap = { version = "4", features = ["derive"] }
 indoc = "2"
 rayon = "1"
@@ -34,3 +34,4 @@ rayon = "1"
 cbindgen = "0.28"
 
 [dev-dependencies]
+tempfile = "3"

data/rust/src/commands/apply.rs

@@ -1,5 +1,14 @@
 use super::run_yerbafile;
 
-pub fn run() {
-  run_yerbafile(true);
+#[derive(clap::Args)]
+#[command(about = "Apply Yerbafile rules to all matching files (or specific files)")]
+pub struct Args {
+  /// Specific files to apply rules to (applies to all if omitted)
+  files: Vec<String>,
+}
+
+impl Args {
+  pub fn run(self) {
+    run_yerbafile(true, self.files);
+  }
 }

data/rust/src/commands/check.rs

@@ -1,5 +1,14 @@
 use super::run_yerbafile;
 
-pub fn run() {
-  run_yerbafile(false);
+#[derive(clap::Args)]
+#[command(about = "Check if files match Yerbafile rules (exits 1 if changes needed)")]
+pub struct Args {
+  /// Specific files to check (checks all if omitted)
+  files: Vec<String>,
+}
+
+impl Args {
+  pub fn run(self) {
+    run_yerbafile(false, self.files);
+  }
 }

data/rust/src/commands/mod.rs

@@ -156,10 +156,8 @@ pub enum Command {
   Selectors(selectors::Args),
   #[command(about = "Create a new Yerbafile in the current directory")]
   Init,
-  #[command(about = "Apply all rules from the Yerbafile and write changes")]
-  Apply,
-  #[command(about = "Check if all files match Yerbafile rules (exits 1 if not)")]
-  Check,
+  Apply(apply::Args),
+  Check(check::Args),
   #[command(about = "Print the yerba version")]
   Version,
   #[command(about = "\u{1f9c9}")]
@@ -184,15 +182,15 @@ impl Command {
       Command::Directives(args) => args.run(),
       Command::Selectors(args) => args.run(),
       Command::Init => init::run(),
-      Command::Apply => apply::run(),
-      Command::Check => check::run(),
+      Command::Apply(args) => args.run(),
+      Command::Check(args) => args.run(),
       Command::Version => version::run(),
       Command::Mate => mate::run(),
     }
   }
 }
 
-pub(crate) fn run_yerbafile(write: bool) {
+pub(crate) fn run_yerbafile(write: bool, files: Vec<String>) {
   use color::*;
 
   let yerbafile_path = yerba::Yerbafile::find().unwrap_or_else(|| {
@@ -207,7 +205,12 @@ pub(crate) fn run_yerbafile(write: bool) {
 
   eprintln!("🧉 {BOLD}Using{RESET} {}", yerbafile_path.display());
 
-  let results = yerbafile.apply(write);
+  let results = if files.is_empty() {
+    yerbafile.apply(write)
+  } else {
+    files.iter().flat_map(|file| yerbafile.apply_file(file, write)).collect()
+  };
+
   let mut has_changes = false;
   let mut has_errors = false;
 

data/rust/src/document/insert.rs

@@ -52,6 +52,76 @@ impl Document {
     self.insert_into(dot_path, &yaml_text, position)
   }
 
+  pub fn insert_objects(&mut self, dot_path: &str, json_values: &[serde_json::Value]) -> Result<(), YerbaError> {
+    if json_values.is_empty() {
+      return Ok(());
+    }
+
+    let quote_style = self.detect_sequence_quote_style(dot_path);
+    let current_node = self.navigate(dot_path)?;
+
+    let sequence = current_node
+      .descendants()
+      .find_map(BlockSeq::cast)
+      .ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
+
+    let entries: Vec<_> = sequence.entries().collect();
+
+    if entries.is_empty() {
+      return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
+    }
+
+    let indent = entries
+      .get(1)
+      .or(entries.first())
+      .map(|entry| preceding_whitespace_indent(entry.syntax()))
+      .unwrap_or_default();
+
+    let mut new_text = String::new();
+
+    for json_value in json_values {
+      let yaml_text = crate::yaml_writer::json_to_yaml_text(json_value, &quote_style, 0);
+
+      let new_item = if yaml_text.contains('\n') {
+        let item_indent = format!("{}  ", indent);
+        let lines: Vec<&str> = yaml_text.split('\n').collect();
+
+        let min_indent = lines
+          .iter()
+          .skip(1)
+          .filter(|line| !line.trim().is_empty())
+          .map(|line| line.len() - line.trim_start().len())
+          .min()
+          .unwrap_or(0);
+
+        let indented: Vec<String> = lines
+          .iter()
+          .enumerate()
+          .map(|(index, line)| {
+            if index == 0 {
+              line.to_string()
+            } else if line.trim().is_empty() {
+              String::new()
+            } else {
+              let relative = &line[min_indent..];
+              format!("{}{}", item_indent, relative)
+            }
+          })
+          .collect();
+
+        format!("- {}", indented.join("\n"))
+      } else {
+        format!("- {}", yaml_text)
+      };
+
+      new_text.push_str(&format!("\n{}{}", indent, new_item));
+    }
+
+    let last_entry = entries.last().unwrap();
+
+    self.insert_after_node(last_entry.syntax(), &new_text)
+  }
+
   pub fn insert_into(&mut self, dot_path: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
     Self::validate_path(dot_path)?;
 

data/rust/src/document/set.rs

@@ -33,7 +33,17 @@ impl Document {
     }
 
     for node in nodes.into_iter().rev() {
-      if let Some(scalar_token) = find_scalar_token(&node) {
+      if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
+        let new_text = if value.is_empty() {
+          "\"\"".to_string()
+        } else if value.contains('\n') {
+          format!("|-\n  {}", value.replace('\n', "\n  "))
+        } else {
+          format!("\"{}\"", value.replace('"', "\\\""))
+        };
+
+        self.apply_edit(block_scalar.text_range(), &new_text)?;
+      } else if let Some(scalar_token) = find_scalar_token(&node) {
         let new_text = format_scalar_value(value, scalar_token.kind());
 
         self.replace_token(&scalar_token, &new_text)?;

data/rust/src/document/sort.rs

@@ -109,9 +109,7 @@ impl Document {
   }
 
   pub fn validate_sort_keys(&self, dot_path: &str, key_order: &[&str]) -> Result<(), YerbaError> {
-    if dot_path == "[]" || dot_path.ends_with(".[]") {
-      let sequence_path = if dot_path == "[]" { "" } else { &dot_path[..dot_path.len() - 3] };
-
+    if let Some(sequence_path) = strip_bracket_suffix(dot_path) {
       return self.validate_each_sort_keys(sequence_path, key_order);
     }
 
@@ -136,9 +134,7 @@ impl Document {
   }
 
   pub fn sort_keys(&mut self, dot_path: &str, key_order: &[&str]) -> Result<(), YerbaError> {
-    if dot_path == "[]" || dot_path.ends_with(".[]") {
-      let sequence_path = if dot_path == "[]" { "" } else { &dot_path[..dot_path.len() - 3] };
-
+    if let Some(sequence_path) = strip_bracket_suffix(dot_path) {
       return self.sort_each_keys(sequence_path, key_order);
     }
 
@@ -200,72 +196,85 @@ impl Document {
   }
 
   pub fn sort_each_keys(&mut self, dot_path: &str, key_order: &[&str]) -> Result<(), YerbaError> {
-    let current_node = self.navigate(dot_path)?;
-
-    let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
-      Some(sequence) => sequence,
-      None => return Ok(()),
+    let nodes = if dot_path.is_empty() {
+      match self.navigate(dot_path) {
+        Ok(node) => vec![node],
+        Err(_) => return Ok(()),
+      }
+    } else {
+      let found = self.navigate_all(dot_path);
+      if found.is_empty() {
+        return Ok(());
+      }
+      found
     };
 
     let mut edits: Vec<(TextRange, String)> = Vec::new();
 
-    for entry in sequence.entries() {
-      let entry_node = entry.syntax();
-
-      let map = match entry_node.descendants().find_map(BlockMap::cast) {
-        Some(map) => map,
+    for current_node in &nodes {
+      let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
+        Some(sequence) => sequence,
         None => continue,
       };
 
-      let entries: Vec<_> = map.entries().collect();
+      for entry in sequence.entries() {
+        let entry_node = entry.syntax();
 
-      if entries.len() <= 1 {
-        continue;
-      }
+        let map = match entry_node.descendants().find_map(BlockMap::cast) {
+          Some(map) => map,
+          None => continue,
+        };
 
-      let (groups, group_range) = collect_groups_with_range(map.syntax());
+        let entries: Vec<_> = map.entries().collect();
 
-      let mut keyed: Vec<(String, EntryGroup)> = entries
-        .iter()
-        .zip(groups)
-        .map(|(entry, group)| {
-          let key_name = entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())).unwrap_or_default();
-          (key_name, group)
-        })
-        .collect();
+        if entries.len() <= 1 {
+          continue;
+        }
 
-      let original_keys: Vec<String> = keyed.iter().map(|(key, _)| key.clone()).collect();
+        let (groups, group_range) = collect_groups_with_range(map.syntax());
+
+        let mut keyed: Vec<(String, EntryGroup)> = entries
+          .iter()
+          .zip(groups)
+          .map(|(entry, group)| {
+            let key_name = entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())).unwrap_or_default();
+            (key_name, group)
+          })
+          .collect();
 
-      keyed.sort_by(|(key_a, _), (key_b, _)| {
-        let position_a = key_order.iter().position(|&key| key == key_a);
-        let position_b = key_order.iter().position(|&key| key == key_b);
+        let original_keys: Vec<String> = keyed.iter().map(|(key, _)| key.clone()).collect();
 
-        match (position_a, position_b) {
-          (Some(a), Some(b)) => a.cmp(&b),
-          (Some(_), None) => std::cmp::Ordering::Less,
-          (None, Some(_)) => std::cmp::Ordering::Greater,
+        keyed.sort_by(|(key_a, _), (key_b, _)| {
+          let position_a = key_order.iter().position(|&key| key == key_a);
+          let position_b = key_order.iter().position(|&key| key == key_b);
 
-          (None, None) => {
-            let original_a = original_keys.iter().position(|key| key == key_a).unwrap();
-            let original_b = original_keys.iter().position(|key| key == key_b).unwrap();
+          match (position_a, position_b) {
+            (Some(a), Some(b)) => a.cmp(&b),
+            (Some(_), None) => std::cmp::Ordering::Less,
+            (None, Some(_)) => std::cmp::Ordering::Greater,
 
-            original_a.cmp(&original_b)
+            (None, None) => {
+              let original_a = original_keys.iter().position(|key| key == key_a).unwrap();
+              let original_b = original_keys.iter().position(|key| key == key_b).unwrap();
+
+              original_a.cmp(&original_b)
+            }
           }
-        }
-      });
+        });
 
-      let sorted_keys: Vec<&str> = keyed.iter().map(|(key, _)| key.as_str()).collect();
-      let orig_refs: Vec<&str> = original_keys.iter().map(|key| key.as_str()).collect();
+        let sorted_keys: Vec<&str> = keyed.iter().map(|(key, _)| key.as_str()).collect();
+        let orig_refs: Vec<&str> = original_keys.iter().map(|key| key.as_str()).collect();
 
-      if sorted_keys == orig_refs {
-        continue;
-      }
+        if sorted_keys == orig_refs {
+          continue;
+        }
 
-      let indent = entries.get(1).map(|entry| preceding_whitespace_indent(entry.syntax())).unwrap_or_default();
+        let indent = entries.get(1).map(|entry| preceding_whitespace_indent(entry.syntax())).unwrap_or_default();
 
-      let sorted_groups: Vec<EntryGroup> = keyed.into_iter().map(|(_, group)| group).collect();
-      let map_text = rebuild_from_groups(&sorted_groups, &indent, false);
-      edits.push((group_range, map_text));
+        let sorted_groups: Vec<EntryGroup> = keyed.into_iter().map(|(_, group)| group).collect();
+        let map_text = rebuild_from_groups(&sorted_groups, &indent, false);
+        edits.push((group_range, map_text));
+      }
     }
 
     if edits.is_empty() {
@@ -292,21 +301,34 @@ impl Document {
   }
 
   pub fn validate_each_sort_keys(&self, dot_path: &str, key_order: &[&str]) -> Result<(), YerbaError> {
-    let current_node = self.navigate(dot_path)?;
-
-    let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
-      Some(sequence) => sequence,
-      None => return Ok(()),
+    let nodes = if dot_path.is_empty() {
+      match self.navigate(dot_path) {
+        Ok(node) => vec![node],
+        Err(_) => return Ok(()),
+      }
+    } else {
+      let found = self.navigate_all(dot_path);
+      if found.is_empty() {
+        return Ok(());
+      }
+      found
     };
 
     let mut all_unknown: Vec<String> = Vec::new();
 
-    for entry in sequence.entries() {
-      if let Some(map) = entry.syntax().descendants().find_map(BlockMap::cast) {
-        for map_entry in map.entries() {
-          if let Some(key_name) = map_entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())) {
-            if !key_order.contains(&key_name.as_str()) && !all_unknown.contains(&key_name) {
-              all_unknown.push(key_name);
+    for current_node in &nodes {
+      let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
+        Some(sequence) => sequence,
+        None => continue,
+      };
+
+      for entry in sequence.entries() {
+        if let Some(map) = entry.syntax().descendants().find_map(BlockMap::cast) {
+          for map_entry in map.entries() {
+            if let Some(key_name) = map_entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())) {
+              if !key_order.contains(&key_name.as_str()) && !all_unknown.contains(&key_name) {
+                all_unknown.push(key_name);
+              }
             }
           }
         }
@@ -605,3 +627,13 @@ impl Document {
     Ok(())
   }
 }
+
+fn strip_bracket_suffix(path: &str) -> Option<&str> {
+  if path == "[]" {
+    Some("")
+  } else if let Some(stripped) = path.strip_suffix(".[]") {
+    Some(stripped)
+  } else {
+    path.strip_suffix("[]")
+  }
+}

data/rust/src/ffi.rs

@@ -477,6 +477,23 @@ pub unsafe extern "C" fn yerba_document_delete(document: *mut Document, path: *c
   }
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_insert_objects(document: *mut Document, path: *const c_char, json: *const c_char) -> YerbaResult {
+  let document = &mut *document;
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let json_string = CStr::from_ptr(json).to_str().unwrap_or("");
+
+  let json_values: Vec<serde_json::Value> = match serde_json::from_str(json_string) {
+    Ok(values) => values,
+    Err(e) => return YerbaResult::err(&format!("Invalid JSON: {}", e)),
+  };
+
+  match document.insert_objects(selector_string, &json_values) {
+    Ok(()) => YerbaResult::ok(),
+    Err(e) => YerbaResult::err(&e.to_string()),
+  }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_remove(document: *mut Document, path: *const c_char, value: *const c_char) -> YerbaResult {
   let document = &mut *document;
@@ -609,6 +626,55 @@ pub unsafe extern "C" fn yerba_document_blank_lines(document: *mut Document, pat
   }
 }
 
+/// Caller must free with yerba_string_free.
+#[no_mangle]
+pub unsafe extern "C" fn yerba_yerbafile_find(directory: *const c_char) -> *mut c_char {
+  let start = if directory.is_null() {
+    std::env::current_dir().ok()
+  } else {
+    CStr::from_ptr(directory).to_str().ok().map(std::path::PathBuf::from)
+  };
+
+  let path = match start {
+    Some(dir) => crate::Yerbafile::find_from(dir),
+    None => None,
+  };
+
+  match path {
+    Some(path) => CString::new(path.to_string_lossy().to_string()).unwrap_or_default().into_raw(),
+    None => ptr::null_mut(),
+  }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_apply_yerbafile(document: *mut Document, file_path: *const c_char, yerbafile_path: *const c_char) -> YerbaResult {
+  let document = &mut *document;
+  let file_path_string = CStr::from_ptr(file_path).to_str().unwrap_or("");
+
+  let yerbafile = if yerbafile_path.is_null() {
+    match crate::Yerbafile::find() {
+      Some(path) => match crate::Yerbafile::load(&path) {
+        Ok(yerbafile) => yerbafile,
+        Err(e) => return YerbaResult::err(&e.to_string()),
+      },
+
+      None => return YerbaResult::err("No Yerbafile found"),
+    }
+  } else {
+    let path = CStr::from_ptr(yerbafile_path).to_str().unwrap_or("");
+
+    match crate::Yerbafile::load(path) {
+      Ok(yerbafile) => yerbafile,
+      Err(e) => return YerbaResult::err(&e.to_string()),
+    }
+  };
+
+  match yerbafile.apply_to_document(document, file_path_string) {
+    Ok(_) => YerbaResult::ok(),
+    Err(e) => YerbaResult::err(&e.to_string()),
+  }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_to_string(document: *const Document) -> *mut c_char {
   let document = &*document;

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

@@ -195,9 +195,13 @@ impl 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 {
@@ -356,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> {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: x86_64-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