yerba 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94b2ac4e51da56b45d0c8070a7780312e44c6a9965d0413f46d0980fbdaedab3
-  data.tar.gz: a52d99bd24a81e27e12f5ac886e1456ef04f1c78b64d3147c44355a88037af52
+  metadata.gz: 63abf64d4cc9319d72226b4c0a01757e2ef3770f3b5eb5d50691f9dba8d5541c
+  data.tar.gz: c809e6afbcf9dac67783853cab1b34017458204eadfc2a58bf82cf6b4d58afdd
 SHA512:
-  metadata.gz: 0401e45b9dd222f415adea842d94ab70c85c02c60d378b79e88499ae88091fe86c457d19d8261612a9673412cf615eb3cf65095e3705ce617585ee05de2ddb83
-  data.tar.gz: 832cba46baf97c184b030e83fbb9b0418bc3af100541710a981d171f974a0417aaafb852d030dd2f1de04e5abce97a709a74f7b6130b4737c08abb3c539e8ee5
+  metadata.gz: a6df761da07e009e2207f66d1fdc745733e3575e3faa5a1708d7d51ac37f03ac5cbd0f567962ed8e747e79396eed486794131915c1cf5350d1e82dc6451a90f7
+  data.tar.gz: ae74066e2fa54fc7e6eaa8defd68e786e18ab5bc871ba48996fb35536543fd7ef9f9e330d20855846a43d8e9718ba9d957a165c37c4391fcdb43984492f5d4b0

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.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> {

data/rust/src/document/get.rs

@@ -53,10 +53,12 @@ impl Document {
 
     let current_node = self.navigate(dot_path).ok()?;
 
-    if current_node
-      .descendants()
-      .any(|child| child.kind() == SyntaxKind::BLOCK_MAP || child.kind() == SyntaxKind::BLOCK_SEQ)
-    {
+    if current_node.descendants().any(|child| {
+      matches!(
+        child.kind(),
+        SyntaxKind::BLOCK_MAP | SyntaxKind::BLOCK_SEQ | SyntaxKind::FLOW_SEQ | SyntaxKind::FLOW_MAP
+      )
+    }) {
       return None;
     }
 
@@ -130,24 +132,11 @@ impl Document {
   }
 
   pub fn node_type(&self, dot_path: &str) -> NodeType {
-    match self.navigate(dot_path) {
-      Ok(node) => {
-        if let Some(first_structural) = node
-          .descendants()
-          .find(|child| BlockMap::can_cast(child.kind()) || BlockSeq::can_cast(child.kind()))
-        {
-          if BlockMap::can_cast(first_structural.kind()) {
-            NodeType::Map
-          } else {
-            NodeType::Sequence
-          }
-        } else if extract_scalar(&node).is_some() {
-          NodeType::Scalar
-        } else {
-          NodeType::NotFound
-        }
-      }
-      Err(_) => NodeType::NotFound,
+    match self.get_value(dot_path) {
+      Some(yaml_serde::Value::Mapping(_)) => NodeType::Map,
+      Some(yaml_serde::Value::Sequence(_)) => NodeType::Sequence,
+      Some(_) => NodeType::Scalar,
+      None => NodeType::NotFound,
     }
   }
 
@@ -278,7 +267,7 @@ impl Document {
       .collect()
   }
 
-  pub fn get_value(&self, dot_path: &str) -> Option<serde_yaml::Value> {
+  pub fn get_value(&self, dot_path: &str) -> Option<yaml_serde::Value> {
     if dot_path.is_empty() {
       return Some(node_to_yaml_value(&self.root));
     }
@@ -292,15 +281,15 @@ impl Document {
         return None;
       }
 
-      let values: Vec<serde_yaml::Value> = padded
+      let values: Vec<yaml_serde::Value> = padded
         .iter()
         .map(|maybe_node| match maybe_node {
           Some(node) => node_to_yaml_value(node),
-          None => serde_yaml::Value::Null,
+          None => yaml_serde::Value::Null,
         })
         .collect();
 
-      Some(serde_yaml::Value::Sequence(values))
+      Some(yaml_serde::Value::Sequence(values))
     } else {
       let nodes = self.navigate_all_compact(dot_path);
 
@@ -312,13 +301,13 @@ impl Document {
         return Some(node_to_yaml_value(&nodes[0]));
       }
 
-      let values: Vec<serde_yaml::Value> = nodes.iter().map(node_to_yaml_value).collect();
+      let values: Vec<yaml_serde::Value> = nodes.iter().map(node_to_yaml_value).collect();
 
-      Some(serde_yaml::Value::Sequence(values))
+      Some(yaml_serde::Value::Sequence(values))
     }
   }
 
-  pub fn get_values(&self, dot_path: &str) -> Vec<serde_yaml::Value> {
+  pub fn get_values(&self, dot_path: &str) -> Vec<yaml_serde::Value> {
     let parsed = crate::selector::Selector::parse(dot_path);
 
     if parsed.has_wildcard() {
@@ -327,7 +316,7 @@ impl Document {
         .iter()
         .map(|maybe_node| match maybe_node {
           Some(node) => node_to_yaml_value(node),
-          None => serde_yaml::Value::Null,
+          None => yaml_serde::Value::Null,
         })
         .collect()
     } else {
@@ -397,6 +386,42 @@ impl Document {
       .collect()
   }
 
+  pub fn get_collection_style(&self, dot_path: &str) -> Option<&'static str> {
+    let current_node = self.navigate(dot_path).ok()?;
+
+    for descendant in current_node.descendants() {
+      match descendant.kind() {
+        SyntaxKind::FLOW_SEQ | SyntaxKind::FLOW_MAP => return Some("flow"),
+        SyntaxKind::BLOCK_SEQ | SyntaxKind::BLOCK_MAP => return Some("block"),
+        _ => {}
+      }
+    }
+
+    None
+  }
+
+  pub fn get_sequence_indent(&self, dot_path: &str) -> Option<&'static str> {
+    let current_node = self.navigate(dot_path).ok()?;
+
+    let sequence = current_node.descendants().find_map(BlockSeq::cast)?;
+    let first_entry = sequence.entries().next()?;
+
+    let entry_indent = preceding_whitespace_indent(first_entry.syntax());
+
+    let entry_node = current_node.ancestors().find(|ancestor| ancestor.kind() == SyntaxKind::BLOCK_MAP_ENTRY)?;
+
+    let source = self.root.text().to_string();
+    let entry_start: usize = entry_node.text_range().start().into();
+    let line_start = source[..entry_start].rfind('\n').map(|position| position + 1).unwrap_or(0);
+    let key_indent = &source[line_start..entry_start];
+
+    if entry_indent.len() > key_indent.len() {
+      Some("indented")
+    } else {
+      Some("compact")
+    }
+  }
+
   pub fn get_quote_style(&self, dot_path: &str) -> Option<&'static str> {
     let current_node = self.navigate(dot_path).ok()?;