yerba 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb111282dd32e6a5bf4f79fc20fb71b1e4f40f56424b27ee74d14e581ca4f645
-  data.tar.gz: 6e3e5e7066e624e3263beaee6c76cebfc02c4ab645c282bfc8760264f5e19ae3
+  metadata.gz: 9b0696495b8437f9deea398cba7c4e6af00a8983ffa0cb519492aca22426ba46
+  data.tar.gz: 42daabe671e951b350286a5ec6a63690466aff8f8b8828ebd8e570e8fc8758d3
 SHA512:
-  metadata.gz: 6d489126e1fbec945069ad81e6b16775a562133364a9a196061d7024248c155ef72e11c73ffcd292bf69ddf601545ba32087cce155d64f3673a91487b2a0a0d1
-  data.tar.gz: 75403eab424bfd79654703fc43640ee45f5e8b9f0142805e4fce938bb27c5bc510046d602ccd1a8c2be082c749a29454fd15aae2f1b2de90c05c6d22bd04dd0a
+  metadata.gz: 2e245101d150f74c63f49a8caaa7e78f7966f25934ee6678a42629b4633758d6f74e3e638892dd4972ec11f0f2c734f93df85debebe809abcbaad19ca67380f5
+  data.tar.gz: 289f195705e6d427bb6f263b8dc826b1107923cdd7022594d2806e47906f6acac3011ae9fb40802e6313bda281d66662168a93c525d5868e14e9435a99758f8b

data/README.md

@@ -47,7 +47,7 @@ Use `yerba` as a library in your Rust project:
 
 ```toml
 [dependencies]
-yerba = "0.5"
+yerba = "0.7"
 ```
 
 ```rust
@@ -476,49 +476,58 @@ yerba check
 yerba check path/to/file.yml
 ```
 
-Each rule specifies a file glob and a list of steps to run in order:
+A Yerbafile supports a global `pipeline` that runs on all matching files, plus per-rule pipelines for file-specific steps. Global steps run first, then per-rule steps refine or override:
 
 ```yaml
+files: "data/**/*.yml"
+
+pipeline:
+  - directives:
+      max: 1
+      ensure: true
+
+  - collection_style:
+      style: block
+
+  - sequence_indent:
+      style: indented
+
+  - quote_style:
+      key_style: plain
+      value_style: double
+
 rules:
-  - files: "config/**/*.yml"
+  - files: "data/**/videos.yml"
     pipeline:
       - quote_style:
-          key_style: plain
-          value_style: double
+          path: "[].speakers"
+          value_style: plain
 
       - sort_keys:
-          path: ""
+          path: "[]"
           order:
             - id
             - title
-            - description
-
-      - blank_lines:
-          count: 1
+            - speakers
 
   - files: "data/speakers.yml"
     pipeline:
-      - quote_style:
-          key_style: plain
-          value_style: double
-
       - sort_keys:
-          path: ""
+          path: "[]"
           order:
             - name
             - slug
             - github
-            - twitter
-            - website
 
       - sort:
-          path: ""
           by: name
 ```
 
 Available pipeline steps:
 
 - `quote_style` Enforce quote style on keys and/or values, optionally scoped by path
+- `collection_style` Enforce flow or block style on collections
+- `sequence_indent` Enforce compact or indented sequence style
 - `sort_keys` Reorder keys to match a predefined list
 - `sort` Sort sequence items by field(s)
 - `blank_lines` Enforce blank lines between sequence entries
@@ -527,10 +536,9 @@ Available pipeline steps:
 - `delete` Remove a key (supports conditions)
 - `rename` Rename a key
 - `remove` Remove an item from a sequence
-- `directives` Add or remove the document start marker (`---`)
+- `directives` Add or remove the document start marker (`---`), with optional `max` validation
 - `unique` Find or remove duplicate items in a sequence
 - `schema` Validate against a JSON schema (with optional `path` for scoping)
-- `get` Read a value and store it as a variable for subsequent steps
 
 This makes it easy to enforce project-wide YAML conventions in CI:
 
@@ -558,6 +566,65 @@ document = Yerba.parse(<<~YAML)
 YAML
 ```
 
+### Creating Documents
+
+Build documents from Ruby objects:
+
+```ruby
+document = Yerba::Document.from({ name: "Alice", tags: ["ruby", "rails"] })
+document = Yerba::Document.from([{ id: "talk-1", title: "First Talk" }])
+```
+
+Build incrementally using `Document.new` and `root=`:
+
+```ruby
+document = Yerba::Document.new
+document.root = {}
+
+document["name"] = "Event 123"
+document["kind"] = "conference"
+document["tags"] = ["ruby", "rails"]
+document["config"] = { host: "localhost", port: 5432 }
+
+document.save_to!("event.yml")
+```
+
+```yaml
+---
+name: Event 123
+kind: conference
+tags:
+  - ruby
+  - rails
+config:
+  host: localhost
+  port: 5432
+```
+
+Or start with `Document.from` and keep building:
+
+```ruby
+document = Yerba::Document.from({ name: "Event 123" })
+
+document["tags"] = []
+document["tags"] << "ruby"
+document["tags"] << "rails"
+```
+
+Build a sequence document and append entries:
+
+```ruby
+document = Yerba::Document.new
+document.root = []
+
+document << { id: "talk-1", title: "First Talk", speakers: ["Alice"] }
+document << { id: "talk-2", title: "Second Talk", speakers: ["Bob", "Carol"] }
+
+document.save_to!("videos.yml")
+```
+
+`document["key"]` and `document << item` are shortcuts for `document.root["key"]` and `document.root << item`.
+
 ### Reading Values
 
 Use bracket notation (`[]`) to navigate the document. Returns typed node objects (`Scalar`, `Map`, or `Sequence`) that are live references — mutations flow back to the document.
@@ -639,6 +706,27 @@ Insert new keys with positional control:
 document["database"].insert("ssl", true, after: "host")
 ```
 
+Set arrays and hashes as values, they default to block style:
+
+```ruby
+document["database"]["tags"] = ["ruby", "rails"]
+# tags:
+#   - ruby
+#   - rails
+
+document["database"]["settings"] = { pool: 5, timeout: 30 }
+# settings:
+#   pool: 5
+#   timeout: 30
+```
+
+Use `set` with `style: :flow` for inline formatting:
+
+```ruby
+document.root.set("tags", ["ruby", "rails"], style: :flow)
+# tags: [ruby, rails]
+```
+
 Work with sequences using familiar Ruby patterns:
 
 ```ruby
@@ -723,6 +811,40 @@ scalar.quote_style # => :double
 scalar.quote_style = :single
 ```
 
+### Collection Style
+
+Read and change how collections are rendered, flow (inline) or block (multi-line):
+
+```ruby
+document["tags"].collection_style          # => :block or :flow
+document["tags"].collection_style = :flow  # => tags: [ruby, rails]
+document["tags"].collection_style = :block # => tags:\n  - ruby\n  - rails
+```
+
+Works on both sequences and maps:
+
+```ruby
+document["database"].collection_style = :flow  # => database: {host: localhost, port: 5432}
+document["database"].collection_style = :block # => database:\n  host: localhost\n  port: 5432
+```
+
+### Sequence Indent
+
+Control whether sequence items are indented under their key or at the same level:
+
+```ruby
+document["tags"].sequence_indent             # => :indented or :compact
+document["tags"].sequence_indent = :compact  # compact style
+document["tags"].sequence_indent = :indented # indented style
+```
+
+```yaml
+# :compact               # :indented
+tags:                    tags:
+- ruby                     - ruby
+- rails                    - rails
+```
+
 ### Location
 
 Get the precise location (line, column, byte offset) of any selector in a document:
@@ -835,6 +957,12 @@ Write changes back to the original file:
 document.save!
 ```
 
+Save to a new path:
+
+```ruby
+document.save_to!("output.yml")
+```
+
 Or render the document as a string without writing to disk:
 
 ```ruby

data/ext/yerba/yerba.c

@@ -110,9 +110,20 @@ static int should_proceed(struct Document *document, VALUE opts) {
 }
 
 /* Document.new(path) */
-static VALUE document_initialize(VALUE self, VALUE path) {
-  const char *file_path = StringValueCStr(path);
-  YerbaParseResult result = yerba_document_parse_file(file_path);
+static VALUE document_initialize(int argc, VALUE *argv, VALUE self) {
+  VALUE path;
+  rb_scan_args(argc, argv, "01", &path);
+
+  YerbaParseResult result;
+
+  if (NIL_P(path)) {
+    result = yerba_document_parse("---\n");
+    rb_iv_set(self, "@path", Qnil);
+  } else {
+    const char *file_path = StringValueCStr(path);
+    result = yerba_document_parse_file(file_path);
+    rb_iv_set(self, "@path", path);
+  }
 
   if (!result.document) {
     VALUE message = make_utf8_string(result.error);
@@ -122,7 +133,29 @@ static VALUE document_initialize(VALUE self, VALUE path) {
   }
 
   RTYPEDDATA_DATA(self) = result.document;
-  rb_iv_set(self, "@path", path);
+
+  return self;
+}
+
+/* document.replace_content!(content) — re-parse from YAML string, keeping the same Ruby object */
+static VALUE document_replace_content(VALUE self, VALUE content) {
+  const char *yaml_content = StringValueCStr(content);
+  YerbaParseResult result = yerba_document_parse(yaml_content);
+
+  if (!result.document) {
+    VALUE message = make_utf8_string(result.error);
+    yerba_string_free(result.error);
+
+    rb_raise(rb_eParseError, "%s", StringValueCStr(message));
+  }
+
+  struct Document *old_document = get_document(self);
+
+  if (old_document) {
+    yerba_document_free(old_document);
+  }
+
+  RTYPEDDATA_DATA(self) = result.document;
 
   return self;
 }
@@ -1024,7 +1057,8 @@ void Init_yerba(void) {
   rb_cDocument = rb_define_class_under(rb_mYerba, "Document", rb_cObject);
 
   rb_define_alloc_func(rb_cDocument, document_alloc);
-  rb_define_method(rb_cDocument, "initialize", document_initialize, 1);
+  rb_define_method(rb_cDocument, "initialize", document_initialize, -1);
+  rb_define_method(rb_cDocument, "replace_content!", document_replace_content, 1);
   rb_define_singleton_method(rb_cDocument, "parse", document_s_parse, 1);
   rb_define_method(rb_cDocument, "[]", document_bracket, 1);
   rb_define_method(rb_cDocument, "node_at", document_bracket, 1);

data/lib/yerba/document.rb

@@ -12,6 +12,12 @@ module Yerba
       @cache = nil
     end
 
+    def self.from(object, path: nil)
+      document = parse(Formatting.to_yaml_document(object))
+      document.instance_variable_set(:@path, path) if path
+      document
+    end
+
     def selector
       ROOT_SELECTOR
     end
@@ -20,7 +26,19 @@ module Yerba
       self[ROOT_SELECTOR]
     end
 
+    def root=(value)
+      replace_content!(Formatting.to_yaml_document(value))
+    end
+
     def []=(key, value)
+      if root.is_a?(Scalar)
+        raise Error, "document root is not set. Use `document.root = {}` or `document.root = []` first"
+      end
+
+      if root.is_a?(Sequence)
+        raise Error, "document root is a Sequence, not a Map. Use `document << item` to append, or `document.root = {}` to switch to a Map"
+      end
+
       root[key] = value
     end
 
@@ -44,6 +62,11 @@ module Yerba
       to_s
     end
 
+    def save_to!(path)
+      @path = path
+      save!
+    end
+
     def dig(*keys)
       keys.reduce(self) { |node, key| node.nil? ? nil : node[key] }
     end
@@ -67,6 +90,14 @@ module Yerba
     end
 
     def <<(item)
+      if root.is_a?(Scalar)
+        raise Error, "document root is not set. Use `document.root = []` first"
+      end
+
+      if root.is_a?(Map)
+        raise Error, "document root is a Map, not a Sequence. Use `document[\"key\"] = value` to set keys, or `document.root = []` to switch to a Sequence"
+      end
+
       root << item
     end
 

data/lib/yerba/formatting.rb

@@ -75,5 +75,16 @@ module Yerba
       else value.to_s
       end
     end
+
+    def self.to_yaml_document(value)
+      case value
+      when Array
+        value.empty? ? "---\n[]\n" : "---\n#{to_block_yaml_value(value)}\n"
+      when Hash
+        value.empty? ? "---\n{}\n" : "---\n#{to_block_yaml_value(value)}\n"
+      else
+        raise ArgumentError, "expected Array or Hash, got #{value.class}"
+      end
+    end
   end
 end

data/lib/yerba/version.rb

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

data/rust/Cargo.toml

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

data/rust/src/document/insert.rs

@@ -154,7 +154,22 @@ impl Document {
 
         let map = match node.descendants().find_map(BlockMap::cast) {
           Some(map) => map,
-          None => continue,
+          None => {
+            let has_empty_flow_map = node
+              .descendants()
+              .any(|descendant| descendant.kind() == SyntaxKind::FLOW_MAP && !descendant.descendants().any(|child| child.kind() == SyntaxKind::FLOW_MAP_ENTRY));
+
+            if has_empty_flow_map {
+              let selectors = self.resolve_selectors(parent_path);
+
+              if let Some(selector) = selectors.get(i) {
+                self.replace_empty_inline_map(selector, key, value)?;
+                continue;
+              }
+            }
+
+            continue;
+          }
         };
 
         if find_entry_by_key(&map, key).is_some() {
@@ -178,7 +193,35 @@ impl Document {
         };
 
         let indent = " ".repeat(start_col);
-        let new_entry_text = format!("{}: {}", key, value);
+
+        let is_block_value = value.contains('\n') || value.starts_with("- ");
+        let new_entry_text = if is_block_value {
+          let value_indent = format!("{}  ", indent);
+          let lines: Vec<&str> = value.lines().collect();
+
+          let min_indent = lines
+            .iter()
+            .filter(|line| !line.trim().is_empty())
+            .map(|line| line.len() - line.trim_start().len())
+            .min()
+            .unwrap_or(0);
+
+          let indented_lines: Vec<String> = lines
+            .iter()
+            .map(|line| {
+              if line.trim().is_empty() {
+                String::new()
+              } else {
+                let relative = &line[min_indent..];
+                format!("{}{}", value_indent, relative)
+              }
+            })
+            .collect();
+
+          format!("{}:\n{}", key, indented_lines.join("\n"))
+        } else {
+          format!("{}: {}", key, value)
+        };
 
         match &position {
           InsertPosition::After(target_key) => {
@@ -370,10 +413,22 @@ impl Document {
   fn insert_map_key(&mut self, dot_path: &str, key: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
     let current_node = self.navigate(dot_path)?;
 
-    let map = current_node
-      .descendants()
-      .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let map = match current_node.descendants().find_map(BlockMap::cast) {
+      Some(map) => map,
+      None => {
+        let flow_map = current_node.descendants().find(|descendant| descendant.kind() == SyntaxKind::FLOW_MAP);
+
+        if let Some(flow_map_node) = flow_map {
+          let is_empty = !flow_map_node.descendants().any(|descendant| descendant.kind() == SyntaxKind::FLOW_MAP_ENTRY);
+
+          if is_empty {
+            return self.replace_empty_inline_map(dot_path, key, value);
+          }
+        }
+
+        return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
+      }
+    };
 
     let entries: Vec<_> = map.entries().collect();
 
@@ -495,21 +550,93 @@ impl Document {
     }
   }
 
+  fn replace_empty_inline_map(&mut self, dot_path: &str, key: &str, value: &str) -> Result<(), YerbaError> {
+    let current_node = self.navigate(dot_path)?;
+
+    if dot_path.is_empty() {
+      let flow_map = current_node
+        .descendants()
+        .find(|descendant| descendant.kind() == SyntaxKind::FLOW_MAP)
+        .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+      let range = flow_map.text_range();
+
+      let source = self.to_string();
+      let start: usize = range.start().into();
+      let before = &source[..start];
+      let trimmed_length = before.trim_end_matches([' ', '\n']).len();
+
+      let adjusted_range = TextRange::new(rowan::TextSize::from(trimmed_length as u32), range.end());
+      let replacement = format!("\n{}: {}", key, value);
+
+      return self.apply_edit(adjusted_range, &replacement);
+    }
+
+    let (parent_path, map_key) = dot_path.rsplit_once('.').unwrap_or(("", dot_path));
+    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, map_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let entry_indent = preceding_whitespace_indent(entry.syntax());
+    let child_indent = format!("{}  ", entry_indent);
+    let new_entry_text = format!("{}{}: {}", child_indent, key, value);
+
+    let mut range = current_node.text_range();
+
+    if let Some(previous) = current_node.prev_sibling_or_token().and_then(|element| element.into_token()) {
+      if previous.kind() == SyntaxKind::WHITESPACE && !previous.text().contains('\n') {
+        range = TextRange::new(previous.text_range().start(), range.end());
+      }
+    }
+
+    let replacement = format!("\n{}", new_entry_text);
+
+    self.apply_edit(range, &replacement)
+  }
+
   fn replace_empty_inline_sequence(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
+    if dot_path.is_empty() {
+      let current_node = self.navigate(dot_path)?;
+      let flow_seq = current_node
+        .descendants()
+        .find(|descendant| descendant.kind() == SyntaxKind::FLOW_SEQ)
+        .ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
+
+      let new_item = Self::format_sequence_item(value, "");
+      let range = flow_seq.text_range();
+      let source = self.to_string();
+      let start: usize = range.start().into();
+      let before = &source[..start];
+
+      let trimmed_length = before.trim_end_matches([' ', '\n']).len();
+      let adjusted_start = trimmed_length;
+
+      let adjusted_range = TextRange::new(rowan::TextSize::from(adjusted_start as u32), range.end());
+      let replacement = format!("\n{}", new_item);
+
+      return self.apply_edit(adjusted_range, &replacement);
+    }
+
     let (parent_path, key) = dot_path.rsplit_once('.').unwrap_or(("", dot_path));
     let parent_node = self.navigate(parent_path)?;
+
     let map = parent_node
       .descendants()
       .find_map(BlockMap::cast)
       .ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
-    let entry = find_entry_by_key(&map, key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
+    let entry = find_entry_by_key(&map, key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
     let item_indent = format!("{}  ", preceding_whitespace_indent(entry.syntax()));
     let new_item = Self::format_sequence_item(value, &item_indent);
     let current_node = self.navigate(dot_path)?;
-    let mut range = current_node.text_range();
     let inline_comment = self.trailing_inline_comment(&current_node);
 
+    let mut range = current_node.text_range();
+
     if let Some(previous) = current_node.prev_sibling_or_token().and_then(|element| element.into_token()) {
       if previous.kind() == SyntaxKind::WHITESPACE && !previous.text().contains('\n') {
         range = TextRange::new(previous.text_range().start(), range.end());

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Marco Roth