yerba 0.5.1-arm-linux-gnu → 0.6.0-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04faaf878eec2699c126530d1bcaa9401c7038cc923343756dfc8c82cb823f7c
-  data.tar.gz: e22a16868decac1b24fddef2417d9a92a088f6a9855cc7b2cfc8d14fdd117557
+  metadata.gz: bf42e332c712a66c4303193ff8e39cf91c499707246923168fb103ea46eecf52
+  data.tar.gz: c0d76d0345ebbbf8f4f07b2182d83a12a131a2388d8c0c3606a3a6b35d778a27
 SHA512:
-  metadata.gz: af87cfab2d89ad25ecb5abc36252eef72a1b1208bf645014f5fcb53b451ff9e37acd916fb137e5236149e1d683f4809aab48440974edcae654a904e845fc74ee
-  data.tar.gz: ed196893d5326e3b0aa87e1c3070702a568b1869efa4dadc33d518aec73fa42d7122fe46f08f1f9513356a86b8db89b6e21b0a4378d645ddebd3385d7a9b6600
+  metadata.gz: c8edf88e0de46be9b4781ec68b4133d0d8c8936f322724694fa8454c7fc3468f1864f2d5928c1bf0a601126b236871602a6780442369e5609cff5871548b8e1b
+  data.tar.gz: 215d8c085524e5b868da7849d6df18be9e735cc46753dda3d663849dad763a6272253d2c013cb3e2cd0d2833e0cc3942d26e7e2f03211ba64ae4a010acfe6146

data/README.md

@@ -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.1"
+  VERSION = "0.6.0"
 end

data/rust/Cargo.lock

@@ -1772,7 +1772,7 @@ dependencies = [
 
 [[package]]
 name = "yerba"
-version = "0.5.1"
+version = "0.6.0"
 dependencies = [
  "cbindgen",
  "clap",

data/rust/Cargo.toml

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

data/rust/src/document/delete.rs

@@ -43,6 +43,19 @@ impl Document {
     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() {
@@ -61,7 +74,7 @@ impl Document {
 
           let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
-          return self.remove_node(entry.syntax());
+          return self.remove_map_entry(&entry);
         }
 
         let mut ranges: Vec<TextRange> = Vec::new();

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,
     }
   }
 
@@ -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()?;