yerba 0.8.1-aarch64-linux-gnu → 0.9.1-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5750e718701701f89479012747d28006c2fa5a1a7297ecd4ef8fabaa216a6623
-  data.tar.gz: f376137f7ef241fda5a69555517da0229a0a8dbbf5ef5c076d3c9219cd30619b
+  metadata.gz: 511327aa49d8c9f0e9e2c739a059d5e78dcffd11acc85a1dd2b2962f6d60f4a1
+  data.tar.gz: 5717396d5a174922f4ce7ce2050d6bb170ced9ad9b6d22c57a80680160ca9c7a
 SHA512:
-  metadata.gz: 235898aad18aad2d69e8557a044a14abeb21e1afc2cf8dc34e996ac83f659cbc3b6dadeb3c661551a1ab7646712fbbff952edd0bc16c236f3e0e082efed08c6f
-  data.tar.gz: 3cf2b51f451f986f6be9705ba7cc2f2796fe2eda57ac429944ed65749f97b1644edab4e0bf0779b300b84a3028057ff6df34c9500ea3cbc84340f6d3a90880a4
+  metadata.gz: c7b4afdff3d69e24995407c42e0a7f7c775a9648435abb46bdb2a93f876486890b54fadfca20513fa26f8daf35de3e102c0ec75c2a26a5b711e4c92d08fe5d8f
+  data.tar.gz: 98308386a28b1a81680609c9b0f051090bc5f3e9eff94daafa3dad7b64aabdd8c9ebcb1873683a69945262d9d05b657a707ede983887ce4ad41f965bbc36309b

data/README.md

@@ -47,7 +47,7 @@ Use `yerba` as a library in your Rust project:
 
 ```toml
 [dependencies]
-yerba = "0.8"
+yerba = "0.9"
 ```
 
 ```rust
@@ -169,34 +169,62 @@ Use `--condition` to only apply the change when a sibling field matches:
 yerba set config.yml "database.host" "0.0.0.0" --condition ".port == 5432"
 ```
 
+Over a wildcard selector the condition picks out *which* items to edit, the same way it filters in
+`get`. Items that do not match are left alone:
+
+```bash
+yerba set videos.yml "[].title" "New Title" --condition ".id == talk-1"
+```
+
+If the condition matches more than one item the command stops rather than guessing, so add `--all`
+when editing several is what you meant:
+
+```bash
+yerba set videos.yml "[].published" false --plain --condition ".kind == draft" --all
+```
+
 Use `--all` to update all nodes matching a wildcard selector:
 
 ```bash
 yerba set videos.yml "[].description" "" --all
 ```
 
+Values are written in the quote style already at the path, which keeps string edits tidy. A value is quoted anyway when writing it plain would not read back as the string you passed, so `yes` becomes `"yes"` and `12345` becomes `"12345"` — whatever the field held before. Use `--plain` to write a YAML literal instead:
+
+```bash
+yerba set config.yml "database.replica" null --plain
+yerba set config.yml "database.ssl" true --plain
+```
+
 ### `insert`
 
 Insert a new key into a map or a new item into a sequence. By default, new items are appended at the end.
 
 ```bash
-yerba insert config.yml "database.ssl" true
+yerba insert config.yml "database.ssl" true --plain
 yerba insert config.yml "tags" "yaml"
 ```
 
 Control placement with `--before`, `--after`, or `--at`:
 
 ```bash
-yerba insert config.yml "database.ssl" true --after "host"
-yerba insert config.yml "database.ssl" true --before "port"
+yerba insert config.yml "database.ssl" true --plain --after "host"
+yerba insert config.yml "database.ssl" true --plain --before "port"
 yerba insert config.yml "tags" "yaml" --at 0
 yerba insert config.yml "tags" "yaml" --after "ruby"
 ```
 
+Values are written as strings, and quoted whenever writing them plain would change what they mean. `"Conf 2018: A Talk"` stays one string instead of becoming a nested map, and `"12345"` stays a string instead of becoming a number. Use `--plain` to write a YAML literal or a map or sequence fragment instead:
+
+```bash
+yerba insert config.yml "database.ssl" true --plain
+yerba insert speakers.yml "" "name: Bob" --plain --after ".name == Alice"
+```
+
 For sequences of maps, use conditions to position relative to other items:
 
 ```bash
-yerba insert speakers.yml "" "name: Bob" --after ".name == Alice"
+yerba insert speakers.yml "" "name: Bob" --plain --after ".name == Alice"
 yerba insert videos.yml "[0].speakers" "Diana" --before ".name == Charlie"
 ```
 
@@ -324,17 +352,17 @@ yerba quote-style videos.yml "[].description" --values literal
 
 **Value styles** (`--values`):
 
-| Style          | Symbol | Example                  | Behavior                             |                            |
-|----------------|--------|--------------------------|--------------------------------------|----------------------------|
-| `plain`        | —      | `host: localhost`        | Unquoted                             |                            |
-| `single`       | `'`    | `host: 'localhost'`      | Single-quoted                        |                            |
-| `double`       | `"`    | `host: "localhost"`      | Double-quoted, supports `\n` escapes |                            |
-| `literal`      | `\     | -`                       | Preserves newlines                   | Strip trailing newline     |
-| `literal-clip` | `\     | `                        | Preserves newlines                   | Keep one trailing newline  |
-| `literal-keep` | `\     | +`                       | Preserves newlines                   | Keep all trailing newlines |
-| `folded`       | `>-`   | Folds newlines to spaces | Strip trailing newline               |                            |
-| `folded-clip`  | `>`    | Folds newlines to spaces | Keep one trailing newline            |                            |
-| `folded-keep`  | `>+`   | Folds newlines to spaces | Keep all trailing newlines           |                            |
+| Style          | Symbol | Example                  | Behavior                             |
+|----------------|--------|--------------------------|--------------------------------------|
+| `plain`        | —      | `host: localhost`        | Unquoted                             |
+| `single`       | `'`    | `host: 'localhost'`      | Single-quoted                        |
+| `double`       | `"`    | `host: "localhost"`      | Double-quoted, supports `\n` escapes |
+| `literal`      | `\|-`  | Preserves newlines       | Strip trailing newline               |
+| `literal-clip` | `\|`   | Preserves newlines       | Keep one trailing newline            |
+| `literal-keep` | `\|+`  | Preserves newlines       | Keep all trailing newlines           |
+| `folded`       | `>-`   | Folds newlines to spaces | Strip trailing newline               |
+| `folded-clip`  | `>`    | Folds newlines to spaces | Keep one trailing newline            |
+| `folded-keep`  | `>+`   | Folds newlines to spaces | Keep all trailing newlines           |
 
 Block scalars are only converted when scoped to a specific selector. An unscoped `--values double` will not touch existing block scalars.
 
@@ -348,6 +376,52 @@ yerba blank-lines videos.yml "[]" 1
 yerba blank-lines config.yml "tags" 0
 ```
 
+By default every entry after the first is adjusted. Use `--before` to set apart only certain sections of a map and leave their neighbours alone:
+
+```bash
+yerba blank-lines event.yml "" 1 --before "schedule,speakers"
+```
+
+```yaml
+id: rubyconf-2024
+name: RubyConf 2024
+city: Chicago
+
+schedule:
+  - day: 1
+
+speakers:
+  - name: Alice
+```
+
+`--after` is the mirror image, separating a key from what follows it. Listing a key in both sets it apart on both sides:
+
+```bash
+yerba blank-lines event.yml "" 1 --before "location" --after "location"
+```
+
+Keys that are not listed keep whatever spacing they already have, so these flags add separators without reflowing the rest of the document. Sequence entries have no key and are never matched by a filter, which means `--before` and `--after` on a sequence are no-ops.
+
+Use `--skip-empty` to leave placeholder entries tucked against their neighbours. An entry counts as empty when its value is `null`, an empty collection, or an empty string:
+
+```bash
+yerba blank-lines event.yml "" 1 --before "location,speakers,sponsors" --after "location" --skip-empty
+```
+
+```yaml
+id: rubyconf-2024
+name: RubyConf 2024
+
+location:
+  city: Chicago
+  country: US
+
+speakers: []
+sponsors: []
+```
+
+The match is ignored when the entry that *triggered* it is empty, not the one on the other side of the gap. That is why `--after "location"` still separates a populated `location:` block from the empty entries below it, while a bare `location: null` would stay packed. Without `--skip-empty`, every listed key gets its blank line whether or not it holds anything.
+
 ### `directives`
 
 Add or remove the document start marker (`---`):
@@ -535,15 +609,16 @@ Available pipeline steps:
 - `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
-- `set` Set a value (supports conditions)
-- `insert` Insert a new key or sequence item
+- `blank_lines` Enforce blank lines between sequence entries, optionally limited to named map keys with `before` and to non-empty values with `skip_empty`
+- `set` Set a value (supports conditions, and `plain: true` for YAML literals)
+- `insert` Insert a new key or sequence item (`plain: true` for YAML literals and fragments)
 - `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 (`---`), with optional `max` validation
 - `unique` Find or remove duplicate items in a sequence
 - `schema` Validate against a JSON schema (with optional `path` for scoping)
+- `escapes` Spell escaped characters literally where the quote style can carry them (with optional `path` for scoping)
 - `final_newline` Enforce exact number of trailing newlines (`count: 1` by default, strips extras)
 
 This makes it easy to enforce project-wide YAML conventions in CI:
@@ -552,6 +627,36 @@ This makes it easy to enforce project-wide YAML conventions in CI:
 yerba check
 ```
 
+The `escapes` step rewrites double-quoted values in the form yerba would write them, so a character the style can carry is spelled out rather than escaped. Text that arrives from an API or a scraper often carries `\U0001F631` where an emoji belongs, or a long value wrapped across two lines. Both read back correctly either way, but neither is pleasant to review in a diff:
+
+```yaml
+pipeline:
+  - escapes: {}
+```
+
+```diff
+-  title: "Deploying on a Friday \U0001F631"
++  title: "Deploying on a Friday 😱"
+
+-  summary: "Why the deploy went out on a Friday, and
+-    what we changed afterwards"
++  summary: "Why the deploy went out on a Friday, and what we changed afterwards"
+```
+
+Escapes that have to stay do: a control character, a quote or a backslash is still written escaped, since the value would not read back the same otherwise. Plain, single-quoted and block scalars are left alone, and a `path` scopes the step to part of the document.
+
+Every checked file is also scanned for control characters, whatever the pipeline says. Yerba's parser accepts them but libyaml does not, so without this a file could pass `check` in CI and then fail to load in the application that reads it. Offending characters are reported with their line and column:
+
+```console
+$ yerba check
+  ✗ data/rubyconf-taiwan/videos.yml
+    found 2 control characters that YAML parsers reject:
+    U+0008 at line 152, column 34
+    U+0008 at line 154, column 12
+```
+
+Tabs, newlines and carriage returns are fine, and so are characters written escaped as `\xNN` inside a double-quoted value — only literal ones are reported.
+
 ## Ruby API
 
 Yerba includes a native C extension (backed by the same Rust core) that provides a full Ruby API for YAML editing.
@@ -718,6 +823,42 @@ Insert new keys with positional control:
 document["database"].insert("ssl", true, after: "host")
 ```
 
+A `String` is written as a value, not as YAML text, and quoted whenever writing it plain would change what it means. This is the same rule the CLI's `insert` and `set` follow, so `"key: value"` stays one string instead of becoming a nested map:
+
+```ruby
+document["notes"] = "key: value"   # => notes: "key: value"
+document["lines"] = "line\nbreak"  # => lines: "line\nbreak"
+document["item"]  = "- a"          # => item: "- a"
+document["tags"]  = "[a, b]"       # => tags: "[a, b]"
+```
+
+Other types are written as the YAML literal they stand for, so the value you read back is the value you wrote:
+
+```ruby
+document["port"]    = 5432   # => port: 5432
+document["ssl"]     = true   # => ssl: true
+document["replica"] = nil    # => replica: null
+```
+
+Both `set` and `insert` take `plain: true` when the value is YAML text you built yourself, to write it verbatim instead:
+
+```ruby
+document.set("tags", "[a, b]", plain: true)  # => tags: [a, b]
+```
+
+```ruby
+document.insert("tags", "- ruby\n- rails", plain: true)
+# tags:
+#   - ruby
+#   - rails
+```
+
+Use `style:` to pick the quote style for the inserted value. A style that cannot carry the value falls back to double quotes rather than writing something that reads back differently:
+
+```ruby
+document.insert("city", "Berlin", style: :double)  # => city: "Berlin"
+```
+
 Set arrays and hashes as values, they default to block style:
 
 ```ruby
@@ -823,6 +964,16 @@ scalar.quote_style # => :double
 scalar.quote_style = :single
 ```
 
+`Yerba.quote_scalar` writes a value as YAML text without needing a document, using the rule the insert APIs follow. Pass a style to ask for one, and it is honoured unless the value cannot survive it:
+
+```ruby
+Yerba.quote_scalar("plain")            # => "plain"
+Yerba.quote_scalar("key: value")       # => "\"key: value\""
+Yerba.quote_scalar("12345")            # => "\"12345\""
+Yerba.quote_scalar("ok", :single)      # => "'ok'"
+Yerba.quote_scalar("a\nb", :single)    # => "\"a\\nb\""
+```
+
 ### Collection Style
 
 Read and change how collections are rendered, flow (inline) or block (multi-line):

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);
@@ -129,13 +131,18 @@ char *yerba_document_find(const struct Document *document,
 struct YerbaResult yerba_document_set(struct Document *document,
                                       const char *path,
                                       const char *value,
+                                      uintptr_t value_length,
                                       enum YerbaValueType value_type,
+                                      bool plain,
                                       bool all);
 
 struct YerbaResult yerba_document_insert(struct Document *document,
                                          const char *path,
                                          const char *value,
+                                         uintptr_t value_length,
                                          enum YerbaValueType value_type,
+                                         bool plain,
+                                         const char *style,
                                          const char *before,
                                          const char *after,
                                          int64_t at);
@@ -211,6 +218,8 @@ struct YerbaResult yerba_document_apply_yerbafile(struct Document *document,
 
 char *yerba_document_to_string(const struct Document *document);
 
+char *yerba_quote_scalar(const char *value, uintptr_t length, const char *style);
+
 void yerba_string_free(char *s);
 
 void yerba_result_free(struct YerbaResult result);

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);
@@ -414,6 +431,31 @@ static VALUE document_resolve_selectors(VALUE self, VALUE path) {
   return rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
 }
 
+/* Yerba.quote_scalar(value, style = nil) → YAML text for value, quoted when the style cannot carry it. */
+static VALUE yerba_s_quote_scalar(int argc, VALUE *argv, VALUE self) {
+  VALUE value, style_value;
+  rb_scan_args(argc, argv, "11", &value, &style_value);
+
+  StringValue(value);
+
+  const char *style = NULL;
+
+  if (!NIL_P(style_value)) {
+    VALUE style_string = rb_obj_is_kind_of(style_value, rb_cString) ? style_value : rb_sym2str(style_value);
+    style = StringValueCStr(style_string);
+  }
+
+  char *quoted = yerba_quote_scalar(RSTRING_PTR(value), (size_t)RSTRING_LEN(value), style);
+
+  if (quoted == NULL) return value;
+
+  VALUE result = make_utf8_string(quoted);
+
+  yerba_string_free(quoted);
+
+  return result;
+}
+
 /* document.get_quote_style(path) → :plain, :single, :double, :literal, etc. or nil */
 static VALUE document_get_quote_style(VALUE self, VALUE path) {
   struct Document *document = get_document(self);
@@ -574,6 +616,7 @@ static VALUE document_find(int argc, VALUE *argv, VALUE self) {
    The caller must provide a number_buffer of at least 64 bytes. */
 struct TypedValue {
   const char *text;
+  size_t length;
   YerbaValueType type;
 };
 
@@ -598,14 +641,21 @@ static struct TypedValue ruby_to_typed_value(VALUE value, char *number_buffer) {
     result.text = number_buffer;
     result.type = YERBA_VALUE_TYPE_FLOAT;
   } else {
-    result.text = StringValueCStr(value);
+    StringValue(value);
+
+    result.text = RSTRING_PTR(value);
+    result.length = (size_t)RSTRING_LEN(value);
     result.type = YERBA_VALUE_TYPE_STRING;
+
+    return result;
   }
 
+  result.length = strlen(result.text);
+
   return result;
 }
 
-/* document.set(path, value, condition: nil, if_exists: false, if_missing: false) */
+/* document.set(path, value, condition: nil, if_exists: false, if_missing: false, plain: false, all: false) */
 static VALUE document_set(int argc, VALUE *argv, VALUE self) {
   VALUE path, value, opts;
   rb_scan_args(argc, argv, "2:", &path, &value, &opts);
@@ -625,43 +675,58 @@ static VALUE document_set(int argc, VALUE *argv, VALUE self) {
   char number_buffer[64];
   struct TypedValue typed_value = ruby_to_typed_value(value, number_buffer);
   bool all = false;
+  bool plain = false;
 
   if (!NIL_P(opts)) {
     VALUE v_all = rb_hash_aref(opts, ID2SYM(rb_intern("all")));
+    VALUE v_plain = rb_hash_aref(opts, ID2SYM(rb_intern("plain")));
 
     if (RTEST(v_all)) all = true;
+    if (RTEST(v_plain)) plain = true;
   }
 
-  YerbaResult result = yerba_document_set(document, StringValueCStr(path), typed_value.text, typed_value.type, all);
+  YerbaResult result = yerba_document_set(document, StringValueCStr(path), typed_value.text, typed_value.length, typed_value.type, plain, all);
   check_result(result);
 
   return self;
 }
 
-/* document.insert(path, value, before: nil, after: nil, at: nil) */
+/* document.insert(path, value, before: nil, after: nil, at: nil, plain: false, style: nil) */
 static VALUE document_insert(int argc, VALUE *argv, VALUE self) {
   VALUE path, value, opts;
   rb_scan_args(argc, argv, "2:", &path, &value, &opts);
 
   const char *before = NULL;
   const char *after = NULL;
+  const char *style = NULL;
   long long at = -1;
+  bool plain = false;
 
   if (!NIL_P(opts)) {
     VALUE v_before = rb_hash_aref(opts, ID2SYM(rb_intern("before")));
     VALUE v_after = rb_hash_aref(opts, ID2SYM(rb_intern("after")));
     VALUE v_at = rb_hash_aref(opts, ID2SYM(rb_intern("at")));
+    VALUE v_plain = rb_hash_aref(opts, ID2SYM(rb_intern("plain")));
+    VALUE v_style = rb_hash_aref(opts, ID2SYM(rb_intern("style")));
 
     if (!NIL_P(v_before)) before = StringValueCStr(v_before);
     if (!NIL_P(v_after)) after = StringValueCStr(v_after);
     if (!NIL_P(v_at)) at = NUM2LL(v_at);
+    if (RTEST(v_plain)) plain = true;
+
+    if (!NIL_P(v_style)) {
+      VALUE style_string = rb_obj_is_kind_of(v_style, rb_cString) ? v_style : rb_sym2str(v_style);
+      style = StringValueCStr(style_string);
+    }
   }
 
   char number_buffer[64];
   struct TypedValue typed_value = ruby_to_typed_value(value, number_buffer);
 
   struct Document *document = get_document(self);
-  YerbaResult result = yerba_document_insert(document, StringValueCStr(path), typed_value.text, typed_value.type, before, after, at);
+  YerbaResult result =
+      yerba_document_insert(document, StringValueCStr(path), typed_value.text, typed_value.length, typed_value.type, plain, style,
+                            before, after, at);
   check_result(result);
 
   return self;
@@ -1122,6 +1187,7 @@ void Init_yerba(void) {
   rb_require("json");
 
   rb_mYerba = rb_define_module("Yerba");
+  rb_define_module_function(rb_mYerba, "quote_scalar", yerba_s_quote_scalar, -1);
   rb_eError = rb_define_class_under(rb_mYerba, "Error", rb_eStandardError);
   rb_ePathNotFoundError = rb_define_class_under(rb_mYerba, "PathNotFoundError", rb_eError);
   rb_eParseError = rb_define_class_under(rb_mYerba, "ParseError", rb_eError);
@@ -1140,6 +1206,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/formatting.rb

@@ -3,16 +3,7 @@
 module Yerba
   module Formatting
     def self.quote(value, style)
-      case style
-      when :double
-        escaped = value.to_s.gsub("\\", "\\\\").gsub('"', '\\"')
-        "\"#{escaped}\""
-      when :single
-        escaped = value.to_s.gsub("'", "''")
-        "'#{escaped}'"
-      else
-        value.to_s
-      end
+      Yerba.quote_scalar(value.to_s, style)
     end
 
     def self.to_yaml_value(value)
@@ -55,9 +46,13 @@ module Yerba
         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}"
+          case value
+          when Array, Hash
+            if value.empty?
+              "#{prefix}#{key}: #{to_yaml_value(value)}"
+            else
+              "#{prefix}#{key}:\n#{to_block_yaml_value(value, indent + 1)}"
+            end
           else
             "#{prefix}#{key}: #{to_scalar_value(value)}"
           end
@@ -72,6 +67,7 @@ module Yerba
       when true then "true"
       when false then "false"
       when nil then "null"
+      when String then Yerba.quote_scalar(value)
       else value.to_s
       end
     end

data/lib/yerba/map.rb

@@ -32,11 +32,11 @@ module Yerba
       if connected?
         new_path = @selector.empty? ? key.to_s : "#{@selector}.#{key}"
         coerced = coerce_value(value, style: style)
-        is_block_value = coerced.is_a?(String) && (coerced.include?("\n") || coerced.start_with?("- "))
+
+        is_collection = value.is_a?(Array) || value.is_a?(Hash)
+        is_block_value = is_collection && !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
@@ -44,14 +44,14 @@ module Yerba
           document.delete(new_path)
 
           if after_key
-            document.insert(new_path, coerced, after: after_key)
+            document.insert(new_path, coerced, after: after_key, plain: true)
           else
-            document.insert(new_path, coerced)
+            document.insert(new_path, coerced, plain: true)
           end
         elsif document.exists?(new_path)
-          document.set(new_path, coerced)
+          document.set(new_path, coerced, plain: is_collection)
         else
-          document.insert(new_path, coerced)
+          document.insert(new_path, coerced, plain: is_collection)
         end
       else
         @data[key] = value
@@ -62,7 +62,10 @@ module Yerba
       if connected?
         new_path = @selector.empty? ? key.to_s : "#{@selector}.#{key}"
 
-        document.insert(new_path, coerce_value(value, style: style), before: before, after: after)
+        coerced = coerce_value(value, style: style)
+        is_collection = value.is_a?(Array) || value.is_a?(Hash)
+
+        document.insert(new_path, coerced, before: before, after: after, plain: is_collection)
       else
         @data[key] = value
       end

data/lib/yerba/sequence.rb

@@ -60,10 +60,9 @@ module Yerba
         when Hash
           document.insert_object(@selector, item)
         when Scalar
-          document.insert(@selector, item.to_yaml)
+          document.insert(@selector, item.to_yaml, plain: true)
         else
-          formatted = format_for_insert(item.to_s)
-          document.insert(@selector, formatted)
+          document.insert(@selector, item.to_s, style: detect_quote_style)
         end
       else
         @data << item
@@ -425,10 +424,6 @@ module Yerba
       current
     end
 
-    def format_for_insert(value)
-      Formatting.quote(value, detect_quote_style)
-    end
-
     def detect_quote_style
       document.get_quote_style("#{@selector}[0]")
     end

data/lib/yerba/version.rb

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

data/rust/Cargo.lock

@@ -1431,7 +1431,7 @@ dependencies = [
 
 [[package]]
 name = "yerba"
-version = "0.8.1"
+version = "0.9.1"
 dependencies = [
  "anstyle-query",
  "cbindgen",

data/rust/Cargo.toml

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