yerba 0.9.0 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be42a92f67226567e1ce9b74e3a2fdba79b06a3dcb4f3a6636ef1b002f7d67c4
-  data.tar.gz: 5f1183494d12c2b27bc9658b50368d4fa5280fb676fbe9a11c5cb75b8c3deb74
+  metadata.gz: bbff6da2b4fadf2758f9a9711d26bd3ac14c5b8c6ebc9d3630103550d3dfa22b
+  data.tar.gz: 46b35dc5a175e797edf19dbc24fe4961593e2ef4fc5c498c2bd5e5eeb9ca1f85
 SHA512:
-  metadata.gz: d7b82a3ee82fa5fbdcf1bf7a937b7859647b73e3a4bf7d6248b5bddd84477e3cd0aa2b5d0f240d37ead5fad419e4b00c87baa6b846d426f23881cc877c65f496
-  data.tar.gz: 1a6f516d714bfb6ba41099796ce04e94d9090b6eaff9f47366551c00998cd73ff28eb4907bd3e85aa550e08123e7a0219b028951e3a6a649163ee407d07a97a6
+  metadata.gz: '09afa4c8dc4f0f921496c3fd52b26b432fac7815ab0f3dfbfdd0a45e498dc821438eaa2ea0d69946ec284c7baccb173132907550ba591cc7c3001a9fd62f0ba3'
+  data.tar.gz: 1848eee956eb9c53c8a385b902a571052814c9ba997a0e133f7b2dedc168ddd19018864729f8e5811f08eea658feb1c605dbac2284a1c58e5b59d52af6f30205

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.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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.2
 platform: ruby
 authors:
 - Marco Roth
@@ -34,6 +34,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