yerba 0.5.0-aarch64-linux-gnu → 0.6.0-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc22173aad9bed5d4dabd219b9718e9bf213f466c9e85f6d24f5f0bc64069abd
-  data.tar.gz: cbb0d8b0204943b934f14e71a79794da8fa4d61f3b53c3e3f7816092e37e5059
+  metadata.gz: 25f1b44c80d2fea571408d3db9e17d82480f3ec0bc9ba7c44f7facc374a7ff45
+  data.tar.gz: 0b6c9c732054bfe5c95c22587a3d0900128b533a2fb5445ebe7847ad17a6bad6
 SHA512:
-  metadata.gz: 99710aedf80e7fcb22fde5e46b8747af622663dec9610caf20ce823d79124141ac7ac656869bf7da3e72e1c94b4e83f9b4173ad4d6ec6d55215869c2f92343e8
-  data.tar.gz: e10141d157b0fe48f0a2472f4c9cd8085b5ec40b0921ea744243dea1431d3b38bce6bb07909b9348042e16dfea9f013affbd7b43d986fb5673a55f4cab647673
+  metadata.gz: 15c96de98439438601d7c507aed217b0b96dc58afadf532d590ff1fc1d9650f65489a57b520c33878a82c60686e78f44955d5b940158cfbe2367613b5a1b141b
+  data.tar.gz: d7b3a4bf8f4b8943a0454845ab7a0c2ef9ea021b6d410e7667beecec461b7d12453b0437823b46556a7dabab7d2fd7730dca4fe01685bfa7c62fc03ec6cb23bf

data/README.md

@@ -47,7 +47,7 @@ Use `yerba` as a library in your Rust project:
 
 ```toml
 [dependencies]
-yerba = "0.4"
+yerba = "0.5"
 ```
 
 ```rust
@@ -843,31 +843,7 @@ document.to_s
 
 ## Development
 
-After checking out the repo, run `bundle install` to install Ruby dependencies, then `bundle exec rake test` to run the test suite.
-
-### Building from source
-
-The Rust core is in the `rust/` directory, with a workspace `Cargo.toml` at the root so all cargo commands work from the project root:
-
-```bash
-cargo build
-cargo test
-```
-
-The C extension (for the Ruby API) is compiled via `ext/yerba/extconf.rb` which invokes `cargo build` and links against the resulting static library. Running `bundle exec rake compile` will build both the Rust library and the C extension.
-
-### Running the CLI locally
-
-```bash
-cargo run -- get config.yml "database.host"
-```
-
-Or build a release binary:
-
-```bash
-cargo build --release
-./target/release/yerba --help
-```
+See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to set up the repo locally, run tests, and contribute.
 
 ## License
 

data/ext/yerba/include/yerba.h

@@ -90,6 +90,18 @@ struct YerbaResult yerba_document_set_quote_style(struct Document *document,
                                                   const char *path,
                                                   const char *style);
 
+char *yerba_document_get_collection_style(const struct Document *document, const char *path);
+
+struct YerbaResult yerba_document_set_collection_style(struct Document *document,
+                                                       const char *path,
+                                                       const char *style);
+
+char *yerba_document_get_sequence_indent(const struct Document *document, const char *path);
+
+struct YerbaResult yerba_document_set_sequence_indent(struct Document *document,
+                                                      const char *path,
+                                                      const char *style);
+
 bool yerba_document_evaluate_condition(const struct Document *document,
                                        const char *parent_path,
                                        const char *condition);

data/ext/yerba/yerba.c

@@ -374,6 +374,76 @@ static VALUE document_set_quote_style(VALUE self, VALUE path, VALUE style) {
   return self;
 }
 
+/* document.get_collection_style(path) → :flow, :block, or nil */
+static VALUE document_get_collection_style(VALUE self, VALUE path) {
+  struct Document *document = get_document(self);
+  char *style = yerba_document_get_collection_style(document, StringValueCStr(path));
+
+  if (style == NULL) return Qnil;
+
+  VALUE symbol = ID2SYM(rb_intern(style));
+
+  yerba_string_free(style);
+
+  return symbol;
+}
+
+/* document.set_collection_style(path, style) */
+static VALUE document_set_collection_style(VALUE self, VALUE path, VALUE style) {
+  struct Document *document = get_document(self);
+
+  const char *style_string;
+
+  if (RB_TYPE_P(style, T_SYMBOL)) {
+    style_string = rb_id2name(SYM2ID(style));
+  } else if (RB_TYPE_P(style, T_STRING)) {
+    style_string = StringValueCStr(style);
+  } else {
+    rb_raise(rb_eError, "Invalid collection style (expected Symbol or String)");
+  }
+
+  YerbaResult result = yerba_document_set_collection_style(document, StringValueCStr(path), style_string);
+
+  check_result(result);
+
+  return self;
+}
+
+/* document.get_sequence_indent(path) → :compact, :indented, or nil */
+static VALUE document_get_sequence_indent(VALUE self, VALUE path) {
+  struct Document *document = get_document(self);
+  char *style = yerba_document_get_sequence_indent(document, StringValueCStr(path));
+
+  if (style == NULL) return Qnil;
+
+  VALUE symbol = ID2SYM(rb_intern(style));
+
+  yerba_string_free(style);
+
+  return symbol;
+}
+
+/* document.set_sequence_indent(path, style) */
+static VALUE document_set_sequence_indent(VALUE self, VALUE path, VALUE style) {
+  struct Document *document = get_document(self);
+
+  const char *style_string;
+
+  if (RB_TYPE_P(style, T_SYMBOL)) {
+    style_string = rb_id2name(SYM2ID(style));
+  } else if (RB_TYPE_P(style, T_STRING)) {
+    style_string = StringValueCStr(style);
+  } else {
+    rb_raise(rb_eError, "Invalid sequence indent style (expected Symbol or String)");
+  }
+
+  YerbaResult result = yerba_document_set_sequence_indent(document, StringValueCStr(path), style_string);
+
+  check_result(result);
+
+  return self;
+}
+
 /* document.condition?(condition, path: "") */
 static VALUE document_condition_p(int argc, VALUE *argv, VALUE self) {
   VALUE condition, opts;
@@ -965,6 +1035,10 @@ void Init_yerba(void) {
   rb_define_method(rb_cDocument, "resolve_selectors", document_resolve_selectors, 1);
   rb_define_method(rb_cDocument, "get_quote_style", document_get_quote_style, 1);
   rb_define_method(rb_cDocument, "set_quote_style", document_set_quote_style, 2);
+  rb_define_method(rb_cDocument, "get_collection_style", document_get_collection_style, 1);
+  rb_define_method(rb_cDocument, "set_collection_style", document_set_collection_style, 2);
+  rb_define_method(rb_cDocument, "get_sequence_indent", document_get_sequence_indent, 1);
+  rb_define_method(rb_cDocument, "set_sequence_indent", document_set_sequence_indent, 2);
   rb_define_method(rb_cDocument, "exists?", document_exists_p, 1);
   rb_define_method(rb_cDocument, "valid_selector?", document_valid_selector_p, 1);
   rb_define_method(rb_cDocument, "condition?", document_condition_p, -1);

data/lib/yerba/formatting.rb

@@ -14,5 +14,66 @@ module Yerba
         value.to_s
       end
     end
+
+    def self.to_yaml_value(value)
+      case value
+      when Array
+        return "[]" if value.empty?
+
+        items = value.map { |item| to_yaml_value(item) }
+
+        "[#{items.join(", ")}]"
+      when Hash
+        return "{}" if value.empty?
+
+        pairs = value.map { |key, value| "#{key}: #{to_yaml_value(value)}" }
+
+        "{#{pairs.join(", ")}}"
+      when true then "true"
+      when false then "false"
+      when nil then "null"
+      else value.to_s
+      end
+    end
+
+    def self.to_block_yaml_value(value, indent = 0)
+      prefix = "  " * indent
+
+      case value
+      when Array
+        return "[]" if value.empty?
+
+        value.map { |item|
+          if item.is_a?(Hash)
+            inner = to_block_yaml_value(item, indent + 1)
+            "#{prefix}- #{inner.lstrip}"
+          else
+            "#{prefix}- #{to_scalar_value(item)}"
+          end
+        }.join("\n")
+      when Hash
+        return "{}" if value.empty?
+
+        value.map { |key, value|
+          if value.is_a?(Hash) || value.is_a?(Array)
+            inner = to_block_yaml_value(value, indent + 1)
+            "#{prefix}#{key}:\n#{inner}"
+          else
+            "#{prefix}#{key}: #{to_scalar_value(value)}"
+          end
+        }.join("\n")
+      else
+        to_scalar_value(value)
+      end
+    end
+
+    def self.to_scalar_value(value)
+      case value
+      when true then "true"
+      when false then "false"
+      when nil then "null"
+      else value.to_s
+      end
+    end
   end
 end

data/lib/yerba/map.rb

@@ -25,24 +25,44 @@ module Yerba
     end
 
     def []=(key, value)
+      set(key, value)
+    end
+
+    def set(key, value, style: nil)
       if connected?
         new_path = @selector.empty? ? key.to_s : "#{@selector}.#{key}"
-
-        if document.exists?(new_path)
-          document.set(new_path, value)
+        coerced = coerce_value(value, style: style)
+        is_block_value = coerced.is_a?(String) && (coerced.include?("\n") || coerced.start_with?("- "))
+
+        if document.exists?(new_path) && is_block_value
+          # Block-style collections can't replace a scalar via set().
+          # Delete the key and re-insert at the same position.
+          all_keys = keys
+          key_index = all_keys.index(key.to_s)
+          after_key = key_index&.positive? ? all_keys[key_index - 1] : nil
+
+          document.delete(new_path)
+
+          if after_key
+            document.insert(new_path, coerced, after: after_key)
+          else
+            document.insert(new_path, coerced)
+          end
+        elsif document.exists?(new_path)
+          document.set(new_path, coerced)
         else
-          document.insert(new_path, value)
+          document.insert(new_path, coerced)
         end
       else
         @data[key] = value
       end
     end
 
-    def insert(key, value, before: nil, after: nil)
+    def insert(key, value, before: nil, after: nil, style: nil)
       if connected?
         new_path = @selector.empty? ? key.to_s : "#{@selector}.#{key}"
 
-        document.insert(new_path, value, before: before, after: after)
+        document.insert(new_path, coerce_value(value, style: style), before: before, after: after)
       else
         @data[key] = value
       end
@@ -165,6 +185,16 @@ module Yerba
       end
     end
 
+    def collection_style
+      @collection_style || document&.get_collection_style(@selector)
+    end
+
+    def collection_style=(style)
+      document&.set_collection_style(@selector, style)
+
+      @collection_style = style
+    end
+
     private
 
     def format_value(value)
@@ -174,5 +204,19 @@ module Yerba
       else value.to_s
       end
     end
+
+    def coerce_value(value, style: nil)
+      case value
+      when Array, Hash
+        resolved_style = style || :block
+
+        if resolved_style == :flow
+          Formatting.to_yaml_value(value)
+        else
+          Formatting.to_block_yaml_value(value)
+        end
+      else value
+      end
+    end
   end
 end

data/lib/yerba/sequence.rb

@@ -293,6 +293,26 @@ module Yerba
       end
     end
 
+    def collection_style
+      @collection_style || document&.get_collection_style(@selector)
+    end
+
+    def collection_style=(style)
+      document&.set_collection_style(@selector, style)
+
+      @collection_style = style
+    end
+
+    def sequence_indent
+      @sequence_indent || document&.get_sequence_indent(@selector)
+    end
+
+    def sequence_indent=(style)
+      document&.set_sequence_indent(@selector, style)
+
+      @sequence_indent = style
+    end
+
     private
 
     def dig_into(hash, path)

data/lib/yerba/version.rb

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

data/rust/Cargo.lock

@@ -739,6 +739,12 @@ version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
+[[package]]
+name = "libyaml-rs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e126dda6f34391ab7b444f9922055facc83c07a910da3eb16f1e4d9c45dc777"
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.12.1"
@@ -1198,19 +1204,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "serde_yaml"
-version = "0.9.34+deprecated"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
-dependencies = [
- "indexmap",
- "itoa",
- "ryu",
- "serde",
- "unsafe-libyaml",
-]
-
 [[package]]
 name = "slab"
 version = "0.4.12"
@@ -1441,12 +1434,6 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
-[[package]]
-name = "unsafe-libyaml"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
-
 [[package]]
 name = "url"
 version = "2.5.8"
@@ -1770,9 +1757,22 @@ dependencies = [
  "winnow",
 ]
 
+[[package]]
+name = "yaml_serde"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08c7c1b1a6a7c8a6b2741a6c21a4f8918e51899b111cfa08d1288202656e3975"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "libyaml-rs",
+ "ryu",
+ "serde",
+]
+
 [[package]]
 name = "yerba"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "cbindgen",
  "clap",
@@ -1783,9 +1783,9 @@ dependencies = [
  "rowan",
  "serde",
  "serde_json",
- "serde_yaml",
  "tempfile",
  "yaml_parser",
+ "yaml_serde",
 ]
 
 [[package]]

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.5.0"
+version = "0.6.0"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"
@@ -24,7 +24,7 @@ yaml_parser = "0.3"
 rowan = "0.16"
 glob = "0.3"
 serde = { version = "1", features = ["derive"] }
-serde_yaml = "0.9"
+yaml_serde = "0.10"
 serde_json = { version = "1", features = ["preserve_order"] }
 clap = { version = "4", features = ["derive"] }
 indoc = "2"

data/rust/src/commands/get.rs

@@ -112,7 +112,7 @@ impl Args {
         }
       }
 
-      let (values, selectors, lines): (Vec<serde_yaml::Value>, Vec<String>, Vec<usize>) = if select_fields.is_some() {
+      let (values, selectors, lines): (Vec<yaml_serde::Value>, Vec<String>, Vec<usize>) = if select_fields.is_some() {
         if let Some(condition) = &normalized_condition {
           let triples = document.filter_with_selectors(&search_path_string, condition);
           let (values, rest): (Vec<_>, Vec<_>) = triples.into_iter().map(|(v, s, l)| (v, (s, l))).unzip();

data/rust/src/commands/selectors.rs

@@ -116,11 +116,11 @@ impl Args {
   }
 }
 
-fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mut BTreeMap<String, SelectorInfo>, counter: &mut usize) {
+fn collect_selectors(value: &yaml_serde::Value, prefix: &str, selectors: &mut BTreeMap<String, SelectorInfo>, counter: &mut usize) {
   match value {
-    serde_yaml::Value::Mapping(map) => {
+    yaml_serde::Value::Mapping(map) => {
       for (key, child) in map {
-        if let serde_yaml::Value::String(key_string) = key {
+        if let yaml_serde::Value::String(key_string) = key {
           let selector = if prefix.is_empty() {
             key_string.clone()
           } else {
@@ -138,7 +138,7 @@ fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mut BT
       }
     }
 
-    serde_yaml::Value::Sequence(sequence) => {
+    yaml_serde::Value::Sequence(sequence) => {
       let bracket_prefix = format!("{}[]", prefix);
 
       let entry = selectors.entry(bracket_prefix.clone()).or_default();

data/rust/src/commands/sort.rs

@@ -329,7 +329,7 @@ impl Args {
       .map(|item| {
         if by_is_scalar {
           match item {
-            serde_yaml::Value::String(string) => string.clone(),
+            yaml_serde::Value::String(string) => string.clone(),
             _ => serde_json::to_string(&yerba::json::yaml_to_json(item)).unwrap_or_default(),
           }
         } else {

data/rust/src/document/condition.rs

@@ -1,7 +1,7 @@
 use super::*;
 
 impl Document {
-  pub fn filter(&self, dot_path: &str, condition: &str) -> Vec<serde_yaml::Value> {
+  pub fn filter(&self, dot_path: &str, condition: &str) -> Vec<yaml_serde::Value> {
     self
       .navigate_all_compact(dot_path)
       .iter()
@@ -10,7 +10,7 @@ impl Document {
       .collect()
   }
 
-  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Vec<(serde_yaml::Value, String, usize)> {
+  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Vec<(yaml_serde::Value, String, usize)> {
     let source = self.root.text().to_string();
 
     self

data/rust/src/document/delete.rs

@@ -35,17 +35,74 @@ impl Document {
   pub fn delete(&mut self, dot_path: &str) -> Result<(), YerbaError> {
     Self::validate_path(dot_path)?;
 
-    let (parent_path, last_key) = dot_path.rsplit_once('.').unwrap_or(("", dot_path));
-    let parent_node = self.navigate(parent_path)?;
+    let selector = crate::selector::Selector::parse(dot_path);
+    let segments = selector.segments();
+    let last_segment = segments.last().ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let parent_path = selector.parent_path();
 
-    let map = parent_node
-      .descendants()
-      .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    match last_segment {
+      crate::selector::SelectorSegment::Key(last_key) => {
+        let has_wildcard = selector.has_wildcard() || selector.has_brackets();
+
+        if parent_path.is_empty() && !has_wildcard {
+          let parent_node = self.navigate(&parent_path)?;
+          let map = parent_node
+            .descendants()
+            .find_map(BlockMap::cast)
+            .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+          let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+          return self.remove_map_entry(&entry);
+        }
+
+        let parent_nodes = self.navigate_all_compact(&parent_path);
+
+        if parent_nodes.is_empty() {
+          if has_wildcard {
+            return Ok(());
+          }
+
+          return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
+        }
+
+        if parent_nodes.len() == 1 && !has_wildcard {
+          let map = parent_nodes[0]
+            .descendants()
+            .find_map(BlockMap::cast)
+            .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
-    let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+          let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
-    self.remove_node(entry.syntax())
+          return self.remove_map_entry(&entry);
+        }
+
+        let mut ranges: Vec<TextRange> = Vec::new();
+
+        for parent_node in &parent_nodes {
+          if let Some(map) = parent_node.descendants().find_map(BlockMap::cast) {
+            if let Some(entry) = find_entry_by_key(&map, last_key) {
+              ranges.push(removal_range(entry.syntax()));
+            }
+          }
+        }
+
+        if ranges.is_empty() {
+          return Ok(());
+        }
+
+        ranges.reverse();
+
+        for range in ranges {
+          self.apply_edit(range, "")?;
+        }
+
+        Ok(())
+      }
+
+      crate::selector::SelectorSegment::Index(index) => self.remove_at(&parent_path, *index),
+      crate::selector::SelectorSegment::AllItems => Err(YerbaError::SelectorNotFound(dot_path.to_string())),
+    }
   }
 
   pub fn remove(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {