yerba 0.9.1-arm-linux-gnu → 0.9.2-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c707c7ffe315229191bf5abdcb11a4cec4c15fee923526a3a421d25153cb4dbb
-  data.tar.gz: 88005dc082d0dd365c9afdab234524500e4c9cb09f4744b405f4dc34c95857fd
+  metadata.gz: 8b49bb4f346300a0924bc402f297040f7e95d185eec8e58d447c006c841ccdf8
+  data.tar.gz: a66cdd879c698a2de753646009639a7a1175d738c281dea1e5ff7a291d2d40d5
 SHA512:
-  metadata.gz: da39f67f8e2b890eff454dcc40fc982b60ad4625a4e9b8eb474251de69fa8143af74443ce71156ecde9ba98a50091ed67b0fa7ecf008bda2bc0fa0f761811f65
-  data.tar.gz: 4cc8faf84db4bb2dfa266f29697f2177c5c63f4d4ea0cc8125c0514fef526d59b9c95a1d564b0c1099a093aee3b1082493584fb54466a7170789b006880b633f
+  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

@@ -93,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

@@ -1167,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;
@@ -1193,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);

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.1"
+  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.1"
+version = "0.9.2"
 dependencies = [
  "anstyle-query",
  "cbindgen",

data/rust/Cargo.toml

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

data/rust/src/ffi.rs

@@ -342,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.1
+  version: 0.9.2
 platform: arm-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-12 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