yerba 0.2.1-arm-linux-gnu → 0.3.0-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4932b50d51221f38a1e170e33a4220082dbfb83d6ca3e8657abe345cc8f9129
-  data.tar.gz: d15e83275f688c4075595506fe9fd9f74e45cb79ff186a9e8299d0fb436dcea3
+  metadata.gz: cc6149b83a227c95769596f557eb340cfb9bf688f48e7e4cb71597e34a3f81ce
+  data.tar.gz: 7d96130e8ad306e3ee9c8fecac49f59c114c8287e4cc49859995787591a7a17d
 SHA512:
-  metadata.gz: f998d3515c059514abeae4db08b6a61ec7a205adbb6470d0506f239bc29a35ff7c951c9d8b04ac7b0cb7a09142fa98b1ab0a780641bbd4950487247cbfd58e27
-  data.tar.gz: 2a1bbe120c06378ec3ed8eee782d7128834736d99bec481738b3e8d82b0543beda526cba016199f3a5508892323317479cc5184e3bfa524111a14c4607d5d83d
+  metadata.gz: 57b2e57f4561ea5aec247ff2bf5957c032dd14191b3892f8e9d657f16b4b7775d968d9eec6da81e2c018f7a63ca3318475661d462e55e8117bb29420e60d8b93
+  data.tar.gz: d26289169658d82ec1bdf51fa1259c8b9c44eaf1afa7759c32002675e30f3a61eb589df29553da96f8e903e1023ddf19c5a55b6c8cb2b4f2694d68e3be61b708

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

@@ -0,0 +1,169 @@
+/* Generated by cbindgen — do not edit manually */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#ifndef YERBA_H
+#define YERBA_H
+
+typedef enum YerbaNodeType {
+  YERBA_NODE_TYPE_SCALAR = 0,
+  YERBA_NODE_TYPE_MAP = 1,
+  YERBA_NODE_TYPE_SEQUENCE = 2,
+  YERBA_NODE_TYPE_NOT_FOUND = 3,
+} YerbaNodeType;
+
+typedef enum YerbaValueType {
+  YERBA_VALUE_TYPE_NULL = 0,
+  YERBA_VALUE_TYPE_BOOLEAN = 1,
+  YERBA_VALUE_TYPE_INTEGER = 2,
+  YERBA_VALUE_TYPE_FLOAT = 3,
+  YERBA_VALUE_TYPE_STRING = 4,
+} YerbaValueType;
+
+typedef struct Document Document;
+
+typedef struct YerbaParseResult {
+  struct Document *document;
+  char *error;
+} YerbaParseResult;
+
+typedef struct YerbaTypedValue {
+  char *text;
+  enum YerbaValueType value_type;
+} YerbaTypedValue;
+
+typedef struct YerbaTypedList {
+  char *json;
+  uintptr_t length;
+} YerbaTypedList;
+
+typedef struct YerbaLocation {
+  uintptr_t start_offset;
+  uintptr_t end_offset;
+  uintptr_t start_line;
+  uintptr_t start_column;
+  uintptr_t end_line;
+  uintptr_t end_column;
+} YerbaLocation;
+
+typedef struct YerbaGetResult {
+  bool is_list;
+  enum YerbaNodeType node_type;
+  struct YerbaTypedValue single;
+  struct YerbaTypedList list;
+  struct YerbaLocation location;
+  char *key_name;
+  struct YerbaLocation key_location;
+  char *error;
+} YerbaGetResult;
+
+typedef struct YerbaResult {
+  bool success;
+  char *error;
+} YerbaResult;
+
+struct YerbaParseResult yerba_document_parse_file(const char *path);
+
+struct YerbaParseResult yerba_document_parse(const char *content);
+
+void yerba_document_free(struct Document *document);
+
+struct YerbaGetResult yerba_document_get(const struct Document *document, const char *path);
+
+/**
+ * Caller must free with yerba_string_free.
+ */
+char *yerba_document_get_value(const struct Document *document, const char *path);
+
+/**
+ * Caller must free with yerba_string_free.
+ */
+char *yerba_document_get_values(const struct Document *document, const char *path);
+
+int32_t yerba_document_get_quote_style(const struct Document *document, const char *path);
+
+struct YerbaResult yerba_document_set_quote_style(struct Document *document,
+                                                  const char *path,
+                                                  int32_t style);
+
+bool yerba_document_evaluate_condition(const struct Document *document,
+                                       const char *parent_path,
+                                       const char *condition);
+
+bool yerba_document_exists(const struct Document *document, const char *path);
+
+char *yerba_document_find(const struct Document *document,
+                          const char *path,
+                          const char *condition,
+                          const char *select);
+
+struct YerbaResult yerba_document_set(struct Document *document,
+                                      const char *path,
+                                      const char *value,
+                                      enum YerbaValueType value_type,
+                                      bool all);
+
+struct YerbaResult yerba_document_insert(struct Document *document,
+                                         const char *path,
+                                         const char *value,
+                                         const char *before,
+                                         const char *after,
+                                         int64_t at);
+
+struct YerbaResult yerba_document_insert_object(struct Document *document,
+                                                const char *path,
+                                                const char *json,
+                                                const char *before,
+                                                const char *after,
+                                                int64_t at);
+
+struct YerbaResult yerba_document_delete(struct Document *document, const char *path);
+
+struct YerbaResult yerba_document_remove(struct Document *document,
+                                         const char *path,
+                                         const char *value);
+
+struct YerbaResult yerba_document_remove_at(struct Document *document,
+                                            const char *path,
+                                            uintptr_t index);
+
+struct YerbaResult yerba_document_rename(struct Document *document,
+                                         const char *source,
+                                         const char *dest);
+
+struct YerbaResult yerba_document_sort(struct Document *document,
+                                       const char *path,
+                                       const char *by,
+                                       bool case_sensitive);
+
+struct YerbaResult yerba_document_sort_keys(struct Document *document,
+                                            const char *path,
+                                            const char *order);
+
+struct YerbaResult yerba_document_quote_style(struct Document *document,
+                                              const char *path,
+                                              const char *key_style,
+                                              const char *value_style);
+
+struct YerbaResult yerba_document_blank_lines(struct Document *document,
+                                              const char *path,
+                                              uintptr_t count);
+
+char *yerba_document_to_string(const struct Document *document);
+
+void yerba_string_free(char *s);
+
+void yerba_result_free(struct YerbaResult result);
+
+void yerba_get_result_free(struct YerbaGetResult result);
+
+struct YerbaTypedList yerba_glob_get(const char *glob_pattern, const char *path);
+
+struct YerbaTypedList yerba_glob_find(const char *glob_pattern,
+                                      const char *path,
+                                      const char *condition,
+                                      const char *select);
+
+#endif  /* YERBA_H */

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.1"
+  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.1"
+version = "0.3.0"
 dependencies = [
  "cbindgen",
  "clap",

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.2.1"
+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);
+    }
   }
 }