yerba 0.9.0-arm-linux-gnu → 0.9.2-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24b7bd0ed1bbddf7baeaff2439c5d7523a4f0ff9f1dba874f50688def682e8e1
-  data.tar.gz: c6190d6d5b0d6808fc5f3a6350a3dbb3ec0a97efb3f66752ccfec047f2bf4a4a
+  metadata.gz: 8b49bb4f346300a0924bc402f297040f7e95d185eec8e58d447c006c841ccdf8
+  data.tar.gz: a66cdd879c698a2de753646009639a7a1175d738c281dea1e5ff7a291d2d40d5
 SHA512:
-  metadata.gz: 754f91df951d8d46fcf12e0b939d4b10c21dc53fb837d16f77f88f1de3fbfa8b99635ec049df2c049be890583743f78c616196a76ca375d41af938a36e9a2e12
-  data.tar.gz: 3d57c9f9e5ff42f1b294c347939f8abdd82a98a04fcad712169e58c50104ec1adbbc81af4930a7a08e332ce33329e54f8d2f1894f0f2cf1ceb78d55005ce60d5
+  metadata.gz: c3ce02a7e1f57ee29ab86d3880ba0088510d3026277df6677bb1dd173e9e6bb6b2ed5052a6d32c9a860afbab4a17f508a1c989c894ed50cf64e80b2f02fbb8c1
+  data.tar.gz: c60175d27fd5e6d87d54ef16d7a6e6c4aa81f85c57edfb4948e9c4bef8894c4e1d740fa0047f6459dd7d8ba8cfd856c3ca7b50cfef9a6a67202ecbae3d8c1c9e

data/README.md

@@ -1165,6 +1165,33 @@ scalars.first.value = "New Title"
 scalars.first.document.save!
 ```
 
+### Parsing Selectors
+
+`Yerba::Selector` splits a selector into its segments, using the same parser as the rest of Yerba. Keys are Strings, indexes Integers, `[]` is `:all_items` and `*` is `:all_keys`:
+
+```ruby
+selector = Yerba::Selector.parse("[3].talks[1]")
+
+selector.segments   # => [3, "talks", 1]
+selector.parent     # => "[3].talks"
+selector.join("speakers", 0).to_s  # => "[3].talks[1].speakers[0]"
+
+Yerba::Selector.parse("[].speakers[]").segments  # => [:all_items, "speakers", :all_items]
+Yerba::Selector.parse(".title").relative?        # => true
+
+Yerba::Selector.build([3, "talks", 1]).to_s      # => "[3].talks[1]"
+```
+
+`dig` looks a concrete selector up in plain Ruby values, such as the cached `Document#values`, without calling into the native extension. Use it when reading many values from the same document:
+
+```ruby
+values = document.values
+
+Yerba::Selector.parse("[3].talks[1].title").dig(values)  # => same as document.value_at("[3].talks[1].title")
+```
+
+Parsed selectors are cached per string, so parsing the same selector again is free.
+
 ### Saving
 
 Write changes back to the original file:

data/ext/yerba/include/yerba.h

@@ -68,6 +68,8 @@ struct YerbaParseResult yerba_document_parse_file(const char *path);
 
 struct YerbaParseResult yerba_document_parse(const char *content);
 
+uint64_t yerba_document_generation(const struct Document *document);
+
 void yerba_document_free(struct Document *document);
 
 struct YerbaGetResult yerba_document_get(const struct Document *document, const char *path);
@@ -91,6 +93,19 @@ char *yerba_document_resolve_selectors(const struct Document *document, const ch
 
 bool yerba_selector_has_wildcard(const char *path);
 
+/**
+ * Parses a selector into JSON: `{"relative": bool, "segments": [...]}`.
+ *
+ * Keys are encoded as strings, indexes as integers, `[]` as `{"all": "items"}` and `*` as `{"all": "keys"}`.
+ */
+char *yerba_selector_parse(const char *path);
+
+/**
+ * Builds a selector string from a JSON array of segments, encoded like `yerba_selector_parse` returns them.
+ */
+char *yerba_selector_build(const char *segments_json,
+                           bool relative);
+
 char *yerba_document_keys(const struct Document *document, const char *path);
 
 char *yerba_document_get_quote_style(const struct Document *document, const char *path);

data/ext/yerba/yerba.c

@@ -339,6 +339,23 @@ static VALUE document_get_value(VALUE self, VALUE path) {
   return rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
 }
 
+/* document.values → the whole document as Ruby objects, cached until the document changes */
+static VALUE document_values(VALUE self) {
+  struct Document *document = get_document(self);
+  VALUE generation = ULL2NUM(yerba_document_generation(document));
+
+  if (rb_equal(rb_ivar_get(self, rb_intern("values_generation")), generation)) {
+    return rb_ivar_get(self, rb_intern("values"));
+  }
+
+  VALUE values = document_get_value(self, make_utf8_string(""));
+
+  rb_ivar_set(self, rb_intern("values"), values);
+  rb_ivar_set(self, rb_intern("values_generation"), generation);
+
+  return values;
+}
+
 /* document.selectors → ["database", "database.host", "tags", "tags[]", ...] */
 static VALUE document_selectors(VALUE self) {
   struct Document *document = get_document(self);
@@ -1150,6 +1167,30 @@ static VALUE collection_s_find(int argc, VALUE *argv, VALUE self) {
   return rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
 }
 
+/* Selector.native_parse(selector) → {"relative" => bool, "segments" => [...]} */
+static VALUE selector_s_native_parse(VALUE klass, VALUE selector) {
+  char *json = yerba_selector_parse(StringValueCStr(selector));
+
+  if (!json) return Qnil;
+
+  VALUE json_string = make_utf8_string(json);
+  yerba_string_free(json);
+
+  return rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
+}
+
+/* Selector.native_build(segments_json, relative) → selector string */
+static VALUE selector_s_native_build(VALUE klass, VALUE segments_json, VALUE relative) {
+  char *result = yerba_selector_build(StringValueCStr(segments_json), RTEST(relative));
+
+  if (!result) return rb_str_new_cstr("");
+
+  VALUE selector = make_utf8_string(result);
+  yerba_string_free(result);
+
+  return selector;
+}
+
 /* Yerbafile.locate(directory = nil) → path string or nil */
 static VALUE yerbafile_s_locate(int argc, VALUE *argv, VALUE klass) {
   VALUE directory;
@@ -1176,6 +1217,10 @@ void Init_yerba(void) {
   rb_eParseError = rb_define_class_under(rb_mYerba, "ParseError", rb_eError);
   rb_ePathValidationError = rb_define_class_under(rb_mYerba, "PathValidationError", rb_eError);
 
+  VALUE rb_cSelector = rb_define_class_under(rb_mYerba, "Selector", rb_cObject);
+  rb_define_private_method(rb_singleton_class(rb_cSelector), "native_parse", selector_s_native_parse, 1);
+  rb_define_private_method(rb_singleton_class(rb_cSelector), "native_build", selector_s_native_build, 2);
+
   VALUE rb_cCollection = rb_define_class_under(rb_mYerba, "Collection", rb_cObject);
   rb_define_singleton_method(rb_cCollection, "get", collection_s_get, 2);
   rb_define_singleton_method(rb_cCollection, "find", collection_s_find, -1);
@@ -1189,6 +1234,7 @@ void Init_yerba(void) {
   rb_define_method(rb_cDocument, "[]", document_bracket, 1);
   rb_define_method(rb_cDocument, "node_at", document_bracket, 1);
   rb_define_method(rb_cDocument, "value_at", document_get_value, 1);
+  rb_define_method(rb_cDocument, "values", document_values, 0);
   rb_define_method(rb_cDocument, "get_all", document_get_all, 1);
   rb_define_method(rb_cDocument, "location", document_location, -1);
   rb_define_method(rb_cDocument, "locations", document_locations, 1);

data/lib/yerba/selector.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Yerba
+  # A parsed selector, split into its segments.
+  #
+  #   Yerba::Selector.parse("[3].talks[1]").segments  # => [3, "talks", 1]
+  #   Yerba::Selector.parse("[].speakers[]").segments # => [:all_items, "speakers", :all_items]
+  #   Yerba::Selector.parse("database.*").segments    # => ["database", :all_keys]
+  #   Yerba::Selector.parse(".title").relative?       # => true
+  #
+  # Keys are Strings, indexes Integers, `[]` is `:all_items` and `*` is `:all_keys`.
+  #
+  class Selector
+    ALL_KEYS = :all_keys
+    ALL_ITEMS = :all_items
+
+    attr_reader :segments
+
+    def self.parse(selector)
+      return selector if selector.is_a?(Selector)
+
+      string = selector.to_s
+
+      cache[string] ||= begin
+        parsed = native_parse(string)
+
+        new(parsed["segments"].map { |segment| decode(segment) }, relative: parsed["relative"], source: string)
+      end
+    end
+
+    # Builds a selector from segments: Strings (keys), Integers (indexes), `:all_items` or `:all_keys`.
+    #
+    #   Yerba::Selector.build([3, "talks", 1]).to_s # => "[3].talks[1]"
+    #
+    def self.build(segments, relative: false)
+      new(segments, relative: relative)
+    end
+
+    def self.clear_cache!
+      @cache = nil
+    end
+
+    def self.cache
+      @cache ||= {}
+    end
+    private_class_method :cache
+
+    def self.decode(segment)
+      case segment
+      when Hash
+        segment["all"] == "keys" ? ALL_KEYS : ALL_ITEMS
+      else
+        segment
+      end
+    end
+    private_class_method :decode
+
+    def initialize(segments, relative: false, source: nil)
+      @segments = segments.dup.freeze
+      @relative = relative
+      @source = source
+
+      freeze
+    end
+
+    def relative?
+      @relative
+    end
+
+    def absolute?
+      !@relative
+    end
+
+    def empty?
+      segments.empty?
+    end
+
+    def wildcard?
+      segments.any? { |segment| [ALL_ITEMS, ALL_KEYS].include?(segment) }
+    end
+
+    # "[3].talks[1]" => "[3].talks"
+    def parent
+      self.class.build(segments[0...-1], relative: relative?)
+    end
+
+    # Selector.parse("[3]").join("talks", 1) => "[3].talks[1]"
+    def join(*more)
+      self.class.build(segments + more, relative: relative?)
+    end
+
+    def dig(values)
+      raise ArgumentError, "Cannot dig a wildcard selector (#{self}), use Document#find or Collection.find instead" if wildcard?
+
+      segments.reduce(values) do |current, segment|
+        case current
+        when Array
+          segment.is_a?(Integer) ? current[segment] : nil
+        when Hash
+          segment.is_a?(Integer) ? nil : current[segment]
+        end
+      end
+    end
+
+    def to_s
+      @source || self.class.send(:native_build, JSON.generate(encoded_segments), relative?)
+    end
+    alias to_str to_s
+
+    def ==(other)
+      other.is_a?(Selector) && other.segments == segments && other.relative? == relative?
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, segments, relative?].hash
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_s.inspect} #{segments.inspect}>"
+    end
+
+    private
+
+    def encoded_segments
+      segments.map do |segment|
+        case segment
+        when ALL_ITEMS
+          { all: "items" }
+        when ALL_KEYS
+          { all: "keys" }
+        else
+          segment
+        end
+      end
+    end
+  end
+end

data/lib/yerba/version.rb

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

data/lib/yerba.rb

@@ -4,6 +4,7 @@ require "fileutils"
 
 require_relative "yerba/version"
 require_relative "yerba/location"
+require_relative "yerba/selector"
 require_relative "yerba/formatting"
 require_relative "yerba/node"
 require_relative "yerba/scalar"

data/rust/Cargo.lock

@@ -1431,7 +1431,7 @@ dependencies = [
 
 [[package]]
 name = "yerba"
-version = "0.9.0"
+version = "0.9.2"
 dependencies = [
  "anstyle-query",
  "cbindgen",

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.9.0"
+version = "0.9.2"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"

data/rust/src/commands/blank_lines.rs

@@ -34,6 +34,7 @@ pub struct Args {
   /// Comma-separated map keys to separate from what follows them
   #[arg(long)]
   after: Option<String>,
+  /// Leave entries alone when their value is null, an empty collection, or an empty string
   #[arg(long)]
   skip_empty: bool,
   #[arg(long)]

data/rust/src/document/mod.rs

@@ -31,6 +31,7 @@ pub struct LocatedNode {
 
 use std::fs;
 use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
 
 use rowan::ast::AstNode;
 use rowan::{TextRange, TextSize};
@@ -126,10 +127,13 @@ pub enum InsertPosition {
   FromSortOrder(Vec<String>),
 }
 
+static NEXT_GENERATION: AtomicU64 = AtomicU64::new(1);
+
 #[derive(Debug)]
 pub struct Document {
   root: SyntaxNode,
   path: Option<PathBuf>,
+  generation: u64,
 }
 
 impl Document {
@@ -138,7 +142,15 @@ impl Document {
 
     check_duplicate_keys(&tree)?;
 
-    Ok(Document { root: tree, path: None })
+    Ok(Document {
+      root: tree,
+      path: None,
+      generation: NEXT_GENERATION.fetch_add(1, Ordering::Relaxed),
+    })
+  }
+
+  pub fn generation(&self) -> u64 {
+    self.generation
   }
 
   pub fn parse_file(path: impl AsRef<Path>) -> Result<Self, YerbaError> {

data/rust/src/ffi.rs

@@ -217,6 +217,11 @@ const EMPTY_LOCATION: YerbaLocation = YerbaLocation {
   end_column: 0,
 };
 
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_generation(document: *const Document) -> u64 {
+  (*document).generation()
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_free(document: *mut Document) {
   if !document.is_null() {
@@ -337,6 +342,64 @@ pub unsafe extern "C" fn yerba_selector_has_wildcard(path: *const c_char) -> boo
   crate::selector::Selector::parse(selector_string).has_wildcard()
 }
 
+/// Parses a selector into JSON: `{"relative": bool, "segments": [...]}`.
+///
+/// Keys are encoded as strings, indexes as integers, `[]` as `{"all": "items"}` and `*` as `{"all": "keys"}`.
+#[no_mangle]
+pub unsafe extern "C" fn yerba_selector_parse(path: *const c_char) -> *mut c_char {
+  use crate::selector::{Selector, SelectorSegment};
+
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  let selector = Selector::parse(selector_string);
+
+  let segments: Vec<serde_json::Value> = selector
+    .segments()
+    .iter()
+    .map(|segment| match segment {
+      SelectorSegment::Key(key) => serde_json::json!(key),
+      SelectorSegment::Index(index) => serde_json::json!(index),
+      SelectorSegment::AllItems => serde_json::json!({ "all": "items" }),
+      SelectorSegment::AllKeys => serde_json::json!({ "all": "keys" }),
+    })
+    .collect();
+
+  let json = serde_json::json!({ "relative": selector.is_relative(), "segments": segments });
+
+  CString::new(json.to_string()).unwrap_or_default().into_raw()
+}
+
+/// Builds a selector string from a JSON array of segments, encoded like `yerba_selector_parse` returns them.
+#[no_mangle]
+pub unsafe extern "C" fn yerba_selector_build(segments_json: *const c_char, relative: bool) -> *mut c_char {
+  use crate::selector::{Selector, SelectorSegment};
+
+  let json_string = CStr::from_ptr(segments_json).to_str().unwrap_or("[]");
+  let values: Vec<serde_json::Value> = serde_json::from_str(json_string).unwrap_or_default();
+
+  let segments: Vec<SelectorSegment> = values
+    .iter()
+    .filter_map(|value| match value {
+      serde_json::Value::String(key) => Some(SelectorSegment::Key(key.clone())),
+      serde_json::Value::Number(number) => number.as_u64().map(|index| SelectorSegment::Index(index as usize)),
+      serde_json::Value::Object(object) => match object.get("all").and_then(|all| all.as_str()) {
+        Some("items") => Some(SelectorSegment::AllItems),
+        Some("keys") => Some(SelectorSegment::AllKeys),
+        _ => None,
+      },
+      _ => None,
+    })
+    .collect();
+
+  let selector_string = Selector::Absolute(segments).to_selector_string();
+  let selector_string = if relative && !selector_string.is_empty() {
+    format!(".{}", selector_string)
+  } else {
+    selector_string
+  };
+
+  CString::new(selector_string).unwrap_or_default().into_raw()
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_keys(document: *const Document, path: *const c_char) -> *mut c_char {
   let document = &*document;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.2
 platform: arm-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-08-04 00:00:00.000000000 Z
+date: 2026-10-13 00:00:00.000000000 Z
 dependencies: []
 description: A CLI tool for editing YAML while preserving structure, comments, and
   format.
@@ -39,6 +39,7 @@ files:
 - lib/yerba/node.rb
 - lib/yerba/query_result.rb
 - lib/yerba/scalar.rb
+- lib/yerba/selector.rb
 - lib/yerba/sequence.rb
 - lib/yerba/version.rb
 - lib/yerba/yerbafile.rb