yerba 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29db5a562148d3de23fa0a071d7e6c43481bc376e57a01fb68c90537119e3785
-  data.tar.gz: 6e7e32d7779acc555896c77a27c64b6231770e58951877ca36c1efb189539037
+  metadata.gz: 477663fa314d01cbe3c98e8a5a8bdc08c0e26d287bff36d23ae1eea519e81609
+  data.tar.gz: 3a9ce13df82bbebd5cbbfc7590d0d334e841c4314bb059f31047ba707bd9bb1e
 SHA512:
-  metadata.gz: fcc7982270f2875ae541830e4a5343d92834a09bb8a425e3a11fff231a42555f55771359365d07bee692533ba2f1899792924fc5f9c1fab48d46a661d839b842
-  data.tar.gz: f67c13246c8ba1d462e015e117344d9d3d4e00163c8810bd46e36015672e5697e31fd2a457360cda924d38f6ac66c900907ec0bb8bd7a7782ff086cb8f16d8e0
+  metadata.gz: be2932fad743bdf806070d5898f73533e8225994dc8d6581b0f47c5ee79519a8cfc83fd4f88cae4607fe5e36ee85f2cc165f288bbeca0184a9756fe18e7b3b27
+  data.tar.gz: 6251a8c8d261c458781e48a2adc8364172bd999c4ecbcc8e38ba625cf9a2434285efabd96dbfb64eabf78791f5a6a187cb76114bfc37facce78d48aa782696cf

data/README.md

@@ -47,7 +47,7 @@ Use `yerba` as a library in your Rust project:
 
 ```toml
 [dependencies]
-yerba = "0.2"
+yerba = "0.3"
 ```
 
 ```rust
@@ -162,6 +162,12 @@ Use `--condition` to only apply the change when a sibling field matches:
 yerba set config.yml "database.host" "0.0.0.0" --condition ".port == 5432"
 ```
 
+Use `--all` to update all nodes matching a wildcard selector:
+
+```bash
+yerba set videos.yml "[].description" "" --all
+```
+
 ### `insert`
 
 Insert a new key into a map or a new item into a sequence. By default, new items are appended at the end.
@@ -249,15 +255,25 @@ yerba move-key config.yml "database.pool" --after "database.name"
 
 ### `sort`
 
-Sort items in a sequence. For simple scalar sequences, no options are needed. For sequences of maps, use `--by` to specify sort fields. Append `:desc` for descending order:
+Sort items in a sequence. For simple scalar sequences, no options are needed. For sequences of maps, use `--by` to specify the sort field. Use `--order desc` for descending. Repeat `--by` and `--order` for tie-breakers:
 
 ```bash
 yerba sort config.yml "tags"
-yerba sort videos.yml --by "title"
-yerba sort videos.yml --by "date:desc,title"
-yerba sort videos.yml "[].speakers" --by "name"
+yerba sort videos.yml --by ".title"
+yerba sort videos.yml --by ".date" --order desc --by ".title"
+yerba sort videos.yml "[].speakers" --by ".name"
 ```
 
+Use `--order` with a comma-separated list to specify an explicit custom order. All items must be listed:
+
+```bash
+yerba sort videos.yml "[]" --by ".id" --order "talk-c,talk-a,talk-b"
+yerba sort speakers.yml "[]" --by ".name" --order "Charlie,Alice,Bob"
+yerba sort config.yml "tags" --by "." --order "yaml,ruby,rust"
+```
+
+This is useful for reordering items in a specific sequence (e.g., conference schedule order, priority lists) or when an LLM agent needs to rearrange items programmatically.
+
 ### `sort-keys`
 
 Reorder the keys in a map to match a predefined order. If any key in the document is not present in the order list, the command aborts with an error, this ensures you account for every field:
@@ -295,6 +311,57 @@ yerba blank-lines videos.yml "[]" 1
 yerba blank-lines config.yml "tags" 0
 ```
 
+### `selectors`
+
+Show all valid selectors for a YAML file. Useful for discovering the structure of a file and knowing which selectors you can use with other commands:
+
+```bash
+yerba selectors config.yml
+```
+
+Output:
+```
+database
+database.host
+database.port
+tags
+tags[]
+```
+
+For sequences of objects:
+
+```bash
+yerba selectors videos.yml
+```
+
+Output:
+```
+[]
+[].id
+[].title
+[].speakers
+[].speakers[]
+[].speakers[].name
+[].speakers[].slug
+[].video_id
+[].video_provider
+```
+
+Pass a selector to scope the output to a specific subtree:
+
+```bash
+yerba selectors config.yml "database"
+yerba selectors videos.yml "[]"
+yerba selectors videos.yml "[].speakers"
+```
+
+Works with glob patterns to show the union of selectors across multiple files:
+
+```bash
+yerba selectors "data/**/videos.yml"
+yerba selectors "data/**/videos.yml" "[]"
+```
+
 ## `Yerbafile`
 
 A `Yerbafile` is a YAML configuration file that defines formatting and editing rules as pipelines of operations that are applied to your files across your project.
@@ -428,6 +495,12 @@ document["database"]["host"].value = "0.0.0.0"
 document.set("database.port", 3306)
 ```
 
+Set all matching nodes at once with `all: true`:
+
+```ruby
+document.set("[].description", "", all: true)
+```
+
 Insert new keys with positional control:
 
 ```ruby

data/ext/yerba/extconf.rb

@@ -93,19 +93,27 @@ if target_platform
              end
 end
 
-lib_path = File.join(lib_dir, lib_name)
+static_lib = File.join(lib_dir, "libyerba.a")
 
-unless File.exist?(lib_path)
-  abort "ERROR: Shared library not found at #{lib_path}"
-end
+if File.exist?(static_lib)
+  puts "yerba: Static library found at #{static_lib}"
+  $LDFLAGS << " #{static_lib}"
+else
+  lib_path = File.join(lib_dir, lib_name)
 
-puts "yerba: Shared library found at #{lib_path}"
+  unless File.exist?(lib_path)
+    abort "ERROR: Shared library not found at #{lib_path}"
+  end
 
-$LDFLAGS << " -L#{lib_dir} -lyerba"
-$CFLAGS << " -I#{File.join(__dir__, "include")}"
+  puts "yerba: Shared library found at #{lib_path} (dynamic)"
 
-if RbConfig::CONFIG["host_os"].match?(/darwin|linux/)
-  $LDFLAGS << " -Wl,-rpath,#{lib_dir}"
+  $LDFLAGS << " -L#{lib_dir} -lyerba"
+
+  if RbConfig::CONFIG["host_os"].match?(/darwin|linux/)
+    $LDFLAGS << " -Wl,-rpath,#{lib_dir}"
+  end
 end
 
+$CFLAGS << " -I#{File.join(__dir__, "include")}"
+
 create_makefile("yerba/yerba")

data/ext/yerba/include/yerba.h

@@ -102,7 +102,8 @@ char *yerba_document_find(const struct Document *document,
 struct YerbaResult yerba_document_set(struct Document *document,
                                       const char *path,
                                       const char *value,
-                                      enum YerbaValueType value_type);
+                                      enum YerbaValueType value_type,
+                                      bool all);
 
 struct YerbaResult yerba_document_insert(struct Document *document,
                                          const char *path,

data/ext/yerba/yerba.c

@@ -399,6 +399,7 @@ static VALUE document_set(int argc, VALUE *argv, VALUE self) {
   const char *c_value;
   YerbaValueType value_type;
   char number_buffer[64];
+  bool all = false;
 
   if (value == Qnil) {
     c_value = "null";
@@ -422,7 +423,13 @@ static VALUE document_set(int argc, VALUE *argv, VALUE self) {
     value_type = YERBA_VALUE_TYPE_STRING;
   }
 
-  YerbaResult result = yerba_document_set(document, StringValueCStr(path), c_value, value_type);
+  if (!NIL_P(opts)) {
+    VALUE v_all = rb_hash_aref(opts, ID2SYM(rb_intern("all")));
+
+    if (RTEST(v_all)) all = true;
+  }
+
+  YerbaResult result = yerba_document_set(document, StringValueCStr(path), c_value, value_type, all);
   check_result(result);
 
   return self;

data/lib/yerba/version.rb

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

data/lib/yerba.rb

@@ -12,9 +12,14 @@ require_relative "yerba/document"
 require_relative "yerba/collection"
 
 begin
-  require "yerba/yerba"
+  major, minor, = RUBY_VERSION.split(".")
+  require "yerba/#{major}.#{minor}/yerba"
 rescue LoadError
-  # C extension not available, fall back to CLI mode
+  begin
+    require "yerba/yerba"
+  rescue LoadError
+    # C extension not available, fall back to CLI mode
+  end
 end
 
 module Yerba

data/rust/Cargo.lock

@@ -784,7 +784,7 @@ dependencies = [
 
 [[package]]
 name = "yerba"
-version = "0.2.2"
+version = "0.3.0"
 dependencies = [
  "cbindgen",
  "clap",

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.2.2"
+version = "0.3.0"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"
@@ -13,7 +13,7 @@ categories = ["parser-implementations", "development-tools"]
 [lib]
 name = "yerba"
 path = "src/lib.rs"
-crate-type = ["cdylib", "rlib"]
+crate-type = ["cdylib", "staticlib", "rlib"]
 
 [[bin]]
 name = "yerba"

data/rust/src/commands/delete.rs

@@ -3,12 +3,13 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{output, parse_file, run_op};
+use super::{output, parse_file, resolve_files, run_op};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
     yerba delete config.yml "database.pool"
     yerba delete videos.yml "[0].description"
+    yerba delete "data/**/event.yml" "date_precision"
     yerba delete config.yml "database.pool" --dry-run
   "#})
 });
@@ -28,8 +29,12 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    let mut document = parse_file(&self.file);
-    run_op(|| document.delete(&self.selector));
-    output(&self.file, &document, self.dry_run);
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+      let result = document.delete(&self.selector);
+
+      run_op(&resolved_file, &document, result);
+      output(&resolved_file, &document, self.dry_run);
+    }
   }
 }

data/rust/src/commands/get.rs

@@ -3,7 +3,7 @@ use std::sync::LazyLock;
 
 use indoc::indoc;
 
-use super::{colorize_examples, parse_file, resolve_files};
+use super::{colorize_examples, parse_file, resolve_files, show_similar_selectors};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
@@ -64,9 +64,49 @@ impl Args {
 
     let search_path_string = search_path.to_selector_string();
     let mut all_results: Vec<serde_json::Value> = Vec::new();
+    let files = resolve_files(&self.file);
+    let is_glob = files.len() > 1;
 
-    for resolved_file in resolve_files(&self.file) {
-      let document = parse_file(&resolved_file);
+    for resolved_file in &files {
+      let document = parse_file(resolved_file);
+
+      if normalized_condition.is_none() && !document.exists(&self.selector) {
+        if is_glob {
+          continue;
+        }
+
+        use super::color::*;
+
+        eprintln!(
+          "{RED}Error:{RESET} selector \"{}\" not found in {}",
+          self.selector, resolved_file
+        );
+
+        show_similar_selectors(resolved_file, &document, &self.selector);
+        process::exit(1);
+      }
+
+      if let Some(fields) = &select_fields {
+        for field in fields {
+          let field_trimmed = field.trim().trim_start_matches('.');
+          let full_selector = if search_path_string.is_empty() {
+            field_trimmed.to_string()
+          } else {
+            format!("{}.{}", search_path_string, field_trimmed)
+          };
+
+          if !document.exists(&full_selector) {
+            use super::color::*;
+            eprintln!(
+              "{RED}Error:{RESET} select field \"{}\" not found in {}",
+              field.trim(),
+              resolved_file
+            );
+            show_similar_selectors(resolved_file, &document, &full_selector);
+            process::exit(1);
+          }
+        }
+      }
 
       let values: Vec<serde_yaml::Value> = if let Some(condition) = &normalized_condition {
         document.filter(&search_path_string, condition)
@@ -74,16 +114,6 @@ impl Args {
         document.get_values(&search_path_string)
       };
 
-      if values.is_empty()
-        && !selector.has_brackets()
-        && normalized_condition.is_none()
-        && !document.exists(&self.selector)
-      {
-        use super::color::*;
-        eprintln!("{RED}Error:{RESET} path not found: {}", self.selector);
-        process::exit(1);
-      }
-
       for value in values {
         if let Some(field) = &extract_field {
           let field_string = field.to_selector_string();
@@ -121,6 +151,19 @@ impl Args {
       }
     }
 
+    if is_glob && all_results.is_empty() && normalized_condition.is_none() {
+      use super::color::*;
+
+      eprintln!(
+        "{RED}Error:{RESET} selector \"{}\" not found in any of the {} files matching \"{}\"",
+        self.selector,
+        files.len(),
+        self.file
+      );
+
+      process::exit(1);
+    }
+
     if self.raw {
       for value in &all_results {
         match value {

data/rust/src/commands/insert.rs

@@ -3,7 +3,7 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{output, parse_file, run_op};
+use super::{output, parse_file, resolve_files, run_op};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
@@ -99,8 +99,12 @@ impl Args {
         .unwrap_or(yerba::InsertPosition::Last)
     };
 
-    let mut document = parse_file(&self.file);
-    run_op(|| document.insert_into(&self.selector, &resolved_value, position));
-    output(&self.file, &document, self.dry_run);
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+      let result = document.insert_into(&self.selector, &resolved_value, position.clone());
+
+      run_op(&resolved_file, &document, result);
+      output(&resolved_file, &document, self.dry_run);
+    }
   }
 }

data/rust/src/commands/mod.rs

@@ -11,6 +11,7 @@ pub mod move_key;
 pub mod quote_style;
 pub mod remove;
 pub mod rename;
+pub mod selectors;
 pub mod set;
 pub mod sort;
 pub mod sort_keys;
@@ -153,6 +154,7 @@ pub enum Command {
   Sort(sort::Args),
   QuoteStyle(quote_style::Args),
   BlankLines(blank_lines::Args),
+  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")]
@@ -180,6 +182,7 @@ impl Command {
       Command::Sort(args) => args.run(),
       Command::QuoteStyle(args) => args.run(),
       Command::BlankLines(args) => args.run(),
+      Command::Selectors(args) => args.run(),
       Command::Init => init::run(),
       Command::Apply => apply::run(),
       Command::Check => check::run(),
@@ -224,7 +227,7 @@ pub(crate) fn run_yerbafile(write: bool) {
   }
 
   if !has_changes && !has_errors {
-    eprintln!("  {GREEN}All files match the rules.{RESET}");
+    eprintln!("\n{BOLD}{GREEN}All files match the rules.{RESET}");
   }
 
   if !write && has_changes {
@@ -327,13 +330,77 @@ pub(crate) fn parse_file(file: &str) -> yerba::Document {
   })
 }
 
-pub(crate) fn run_op(operation: impl FnOnce() -> Result<(), yerba::YerbaError>) {
+pub(crate) fn run_op(file: &str, document: &yerba::Document, result: Result<(), yerba::YerbaError>) {
+  run_op_with_hint(file, document, result, None);
+}
+
+pub(crate) fn run_op_with_hint(
+  file: &str,
+  document: &yerba::Document,
+  result: Result<(), yerba::YerbaError>,
+  hint: Option<&str>,
+) {
   use color::*;
 
-  operation().unwrap_or_else(|error| {
-    eprintln!("{RED}Error:{RESET} {}", error);
+  if let Err(error) = result {
+    if let yerba::YerbaError::SelectorNotFound(selector) = &error {
+      eprintln!("{RED}Error:{RESET} selector \"{selector}\" not found in {file}");
+
+      show_similar_selectors(file, document, selector);
+    } else {
+      eprintln!("{RED}Error:{RESET} {}", error);
+    }
+
+    if let Some(hint) = hint {
+      if matches!(error, yerba::YerbaError::SelectorNotFound(_)) {
+        eprintln!();
+        eprintln!("  {DIM}Hint: {hint}{RESET}");
+      }
+    }
+
     process::exit(1);
-  });
+  }
+}
+
+pub(crate) fn show_similar_selectors(file: &str, document: &yerba::Document, invalid_path: &str) {
+  use color::*;
+  use yerba::didyoumean::didyoumean_ranked;
+
+  let selectors = document.selectors();
+
+  if selectors.is_empty() {
+    return;
+  }
+
+  let query = invalid_path.split_whitespace().next().unwrap_or(invalid_path);
+  let threshold = query.len() / 2 + 3;
+  let close = didyoumean_ranked(query, &selectors, threshold);
+
+  eprintln!();
+
+  if close.is_empty() {
+    eprintln!("  {BOLD}Available selectors in {file}:{RESET}");
+
+    for selector in selectors.iter().take(10) {
+      eprintln!("    {DIM}{selector}{RESET}");
+    }
+
+    if selectors.len() > 10 {
+      eprintln!("    {DIM}... and {} more{RESET}", selectors.len() - 10);
+    }
+  } else if close.len() == 1 {
+    eprintln!("  {BOLD}Did you mean this selector?{RESET} {}", close[0]);
+  } else {
+    eprintln!("  {BOLD}Did you mean one of these selectors?{RESET}");
+
+    for selector in close.iter().take(5) {
+      eprintln!("    {selector}");
+    }
+  }
+
+  eprintln!();
+  eprintln!("  {BOLD}To see all valid selectors, run:{RESET}");
+  eprintln!("    yerba selectors \"{file}\"{RESET}");
 }
 
 pub(crate) fn output(file: &str, document: &yerba::Document, dry_run: bool) {

data/rust/src/commands/move_item.rs

@@ -48,7 +48,8 @@ impl Args {
       |document, path, reference| document.resolve_sequence_index(path, reference),
     );
 
-    run_op(|| document.move_item(&self.selector, from_index, to_index));
+    let result = document.move_item(&self.selector, from_index, to_index);
+    run_op(&self.file, &document, result);
     output(&self.file, &document, self.dry_run);
   }
 }

data/rust/src/commands/move_key.rs

@@ -81,7 +81,8 @@ impl Args {
       |document, parent_path, reference| document.resolve_key_index(parent_path, reference),
     );
 
-    run_op(|| document.move_key(parent_path, from_index, to_index));
+    let result = document.move_key(parent_path, from_index, to_index);
+    run_op(&self.file, &document, result);
     output(&self.file, &document, self.dry_run);
   }
 }

data/rust/src/commands/remove.rs

@@ -3,7 +3,7 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{output, parse_file, run_op};
+use super::{output, parse_file, resolve_files, run_op};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
@@ -28,8 +28,12 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    let mut document = parse_file(&self.file);
-    run_op(|| document.remove(&self.selector, &self.value));
-    output(&self.file, &document, self.dry_run);
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+      let result = document.remove(&self.selector, &self.value);
+
+      run_op(&resolved_file, &document, result);
+      output(&resolved_file, &document, self.dry_run);
+    }
   }
 }

data/rust/src/commands/rename.rs

@@ -3,7 +3,7 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{output, parse_file, run_op};
+use super::{output, parse_file, resolve_files, run_op};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
@@ -30,8 +30,12 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    let mut document = parse_file(&self.file);
-    run_op(|| document.rename(&self.source, &self.destination));
-    output(&self.file, &document, self.dry_run);
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+      let result = document.rename(&self.source, &self.destination);
+
+      run_op(&resolved_file, &document, result);
+      output(&resolved_file, &document, self.dry_run);
+    }
   }
 }