Struct SerializerOptions 

#[non_exhaustive]
pub struct SerializerOptions {
    pub empty_as_braces: bool,
    pub indent_step: usize,
    pub compact_list_indent: bool,
    pub anchor_generator: Option<fn(usize) -> String>,
    pub min_fold_chars: usize,
    pub folded_wrap_chars: usize,
    pub tagged_enums: bool,
    pub prefer_block_scalars: bool,
    pub quote_all: bool,
    pub yaml_12: bool,
    pub no_lang_directive: bool,
}

Serializer options for YAML emission.

This struct controls various aspects of YAML serialization, such as indentation, anchor generation, and scalar styles.

Construct SerializerOptions using the ser_options! macro to ensure compatibility with future updates.

use serde::Serialize;
use serde_saphyr::{ser_options, to_string_with_options};

#[derive(Serialize)]
struct Config {
    name: String,
    values: Vec<i32>,
}

let config = Config {
    name: "test".to_string(),
    values: vec![1, 2, 3],
};

// Use 4-space indentation and quote all strings
let options = ser_options! {
    indent_step: 4,
    quote_all: true,
};

let yaml = to_string_with_options(&config, options).unwrap();

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

empty_as_braces: bool

If true, empty maps are emitted as braces {} and empty lists as [] (this is the default). This form is valid YAML, distinguishes empty collections from null, and may be easier for a human to read.

indent_step: usize

Number of spaces to indent per nesting level when emitting block-style collections (2 by default). Values must be in 1..=64.

compact_list_indent: bool

When enabled, emit list items with a more compact indentation style. On by default.

      containers:
      - env:
        - name: METHOD
          value: WATCH

Compared to a more expanded indentation style:

      containers:
        - env:
            - name: METHOD
              value: WATCH

anchor_generator: Option<fn(usize) -> String>

Optional custom anchor-name generator.

Receives a monotonically increasing usize id (starting at 1) and returns the anchor name to emit. If None, the built-in generator yields names like a1, a2, … Generated names must be 1 to 256 bytes and cannot contain whitespace, control characters, or the flow punctuation [, ], {, }, or ,; unsupported names produce a serialization error. The generator remains responsible for returning unique names.

min_fold_chars: usize

Threshold for block-string wrappers (crate::LitStr/crate::FoldStr and owned variants crate::LitString/crate::FoldString).

If the string contains a newline, block style is always used. Otherwise, when the string is single-line and its length is strictly less than this threshold, the serializer emits a normal YAML scalar (no block style). Longer strings use block styles | or > depending on the wrapper. See the type docs for crate::LitStr, crate::FoldStr, crate::LitString and crate::FoldString for examples.

folded_wrap_chars: usize

Maximum width (in characters) for lines in folded block scalars (>).

Lines are wrapped only at whitespace so that each emitted line is at most this many characters long (excluding indentation). If no whitespace is present within the limit (e.g., a single long token), the line is emitted unwrapped to preserve round-trip correctness: YAML folded scalars typically fold inserted newlines back as spaces when parsing. Default: 80.

tagged_enums: bool

When enabled, serialize simple enums that become a single scalar (unit variants) using YAML tags, e.g. !!Enum Variant instead of a plain scalar Variant. Deserializer does not need this setting as both cases will be understood. Off by default.

prefer_block_scalars: bool

When enabled, strings containing more than folded_wrap_chars (80 by default) are written in folded block scalar style (>), and strings containing newlines are written in literal block scalar style (|), selecting chomping based on the number of trailing empty lines. On by default.

quote_all: bool

When enabled, quote all string scalars. Uses single quotes by default, but switches to double quotes when the string contains escape sequences (control characters like \n, \t, \r, backslash) or single quotes. Disables block scalar styles (| and >) for quoted strings when active. Off by default.

yaml_12: bool

When enabled, emit %YAML 1.2 and the required document start marker at the beginning of the document, and use YAML 1.2 rules for certain compatibility heuristics. Set no_lang_directive to suppress the directive and its document start marker while keeping these heuristics.

With the default false, strings matching YAML 1.1 numeric, boolean, null, timestamp, and reserved-token spellings are quoted to preserve their type across readers. With true, YAML 1.1-specific quoting checks are disabled, including boolean spellings like yes/no/on/off/y/n, sexagesimal numbers, and timestamps. YAML syntax safety checks still apply. Default: false.

no_lang_directive: bool

Suppress the %YAML 1.2 directive and its leading --- document start marker when yaml_12 is enabled, without changing string quoting heuristics. Document separators between multiple documents are still emitted. Has no effect when yaml_12 is false. Default: false.

Trait Implementations

impl Clone for SerializerOptions

fn clone(&self) -> SerializerOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SerializerOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SerializerOptions

fn default() -> Self

Returns the “default value” for a type.