Struct ParserConfig 

#[non_exhaustive]
pub struct ParserConfig {

    pub yaml_version: YamlVersion,
    pub max_depth: usize,
    pub max_document_length: usize,
    pub max_stream_bytes: usize,
    pub max_alias_expansions: usize,
    pub max_mapping_keys: usize,
    pub max_sequence_length: usize,
    pub max_events: usize,
    pub max_nodes: usize,
    pub max_total_scalar_bytes: usize,
    pub max_documents: usize,
    pub max_merge_keys: usize,
    pub alias_anchor_ratio: Option<f64>,
    pub duplicate_key_policy: DuplicateKeyPolicy,
    pub strict_booleans: bool,
    pub legacy_booleans: bool,
    pub tag_registry: Option<Arc<TagRegistry>>,
    pub merge_key_policy: MergeKeyPolicy,
    pub no_schema: bool,
    pub legacy_octal_numbers: bool,
    pub ignore_binary_tag_for_string: bool,
    pub plain_scalar_strings: bool,
    pub legacy_sexagesimal: bool,
    pub lossless_u64_integers: bool,
    pub leading_zero_integer_strings: bool,
    pub legacy_binary_numbers: bool,
    pub float_overflow_strings: bool,
    pub integer_overflow_errors: bool,
    pub non_scalar_key_policy: NonScalarKeyPolicy,
    pub alias_jump_event_factor: Option<usize>,
    pub require_indent: RequireIndent,
    pub policies: Vec<Arc<dyn Policy>>,
    pub properties: Option<Arc<HashMap<String, String>>>,
    pub strict_properties: bool,
    pub include_resolver: Option<IncludeResolver>,
    pub max_include_depth: usize,
    pub max_include_sources: usize,
    pub max_total_include_bytes: usize,
    /* private fields */
}

Deserialization configuration.

All fields are public, but the struct is annotated #[non_exhaustive] so that adding a new budget or policy in a future minor release is not a breaking change. Construct with ParserConfig::new / ParserConfig::strict / ParserConfig::default (preferred) or with the ..ParserConfig::default() struct-update form; do not construct from an exhaustive struct-literal outside this crate.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_depth(64);
assert_eq!(cfg.max_depth, 64);

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.

yaml_version: YamlVersion

Which YAML specification version to honour during plain-scalar resolution.

YAML 1.2 (default) follows the core schema — strict true/false booleans, no bare 0-prefix octal, no sexagesimal 60:00 integers. YAML 1.1 broadens the resolver to accept all of those legacy forms.

Setting this to YamlVersion::V1_1 is equivalent to flipping every legacy_* flag (legacy_booleans, legacy_octal_numbers, legacy_sexagesimal) on at once. The legacy_* flags remain available for fine-grained overrides — version selection sets a preset, individual flags refine it.

max_depth: usize

Maximum recursion depth allowed during parsing (default: 128).

max_document_length: usize

Maximum length of a single YAML document in bytes (default: 64 MB).

max_stream_bytes: usize

Maximum total byte length of a multi-document stream (default: 256 MB). Async multi-document readers enforce this before splitting, while each document remains subject to Self::max_document_length.

max_alias_expansions: usize

Maximum number of times a single anchor can be expanded (default: 1024).

max_mapping_keys: usize

Maximum number of keys allowed in a single mapping (default: 64k).

max_sequence_length: usize

Maximum number of elements allowed in a single sequence (default: 64k).

max_events: usize

Maximum total parser events emitted across the input (default: 1 000 000). Caps event-stream amplification independent of recursion depth or alias count. Trips crate::Error::Budget with crate::BudgetBreach::MaxEvents.

max_nodes: usize

Maximum total Value nodes authored into the AST across the input (default: 250 000). Each scalar, sequence, and mapping — empty collections included — counts as one node, so this bounds node-dense payloads (long runs of []/{}) that stay under the scalar-byte and event caps. Trips crate::Error::Budget with crate::BudgetBreach::MaxNodes. Enforced on the AST-loader path and re-applied to the fully expanded include graph; raise it for deliberately large documents.

max_total_scalar_bytes: usize

Maximum cumulative scalar-byte count across the document (default: 64 MB). Distinct from Self::max_document_length (input size) — this caps scalar payload after alias expansion. Trips crate::BudgetBreach::MaxTotalScalarBytes.

max_documents: usize

Maximum number of documents in a multi-document stream (default: 1 000). Trips crate::BudgetBreach::MaxDocuments.

max_merge_keys: usize

Maximum number of merge-key (<<) entries across the document (default: 10 000). Trips crate::BudgetBreach::MaxMergeKeys.

alias_anchor_ratio: Option<f64>

Optional alias-to-anchor ratio heuristic for detecting billion-laughs amplification patterns (default: Some(10.0)). When more than ratio × anchors aliases have been resolved, the parser trips crate::BudgetBreach::AliasAnchorRatio. Set to None to disable.

duplicate_key_policy: DuplicateKeyPolicy

How to handle duplicate keys in a mapping (default: Last, per YAML 1.2).

strict_booleans: bool

If true, only true and false (lowercase) are accepted as booleans.

legacy_booleans: bool

If true, accepts YAML 1.1 booleans like yes, no, on, off.

tag_registry: Option<Arc<TagRegistry>>

Optional registry of custom tags to strip on the streaming path.

See TagRegistry for the full rationale. None (default) preserves the legacy behaviour of routing every custom-tagged value through the AST fallback.

merge_key_policy: MergeKeyPolicy

How the YAML merge key (<<) should be handled.

See MergeKeyPolicy for the available policies. The default is MergeKeyPolicy::Auto — the YAML 1.2 spec behaviour where <<: triggers automatic mapping merge.

no_schema: bool

When true, plain scalars are never resolved to null / bool / int / float — every plain scalar becomes a string. Useful for schema-strict pipelines that require the user to quote intent explicitly. Default false.

legacy_octal_numbers: bool

When true, accept YAML 1.1-style bare 0-prefix octal literals (e.g. 0644 parsed as 420) in addition to the YAML 1.2 0o644 form. Default false to honour the YAML 1.2 schema.

ignore_binary_tag_for_string: bool

When true, deserializing !!binary "ABCD" into a String target yields the literal base64 source string ("ABCD") rather than rejecting on tag mismatch. The canonical bytes path (Vec<u8>, serde_bytes::ByteBuf) still decodes the base64 payload either way. Useful for migrations from Python pyyaml-style applications that treat the tag as advisory. Default false.

plain_scalar_strings: bool

When enabled, a plain scalar deserializes into a String (or char) target as its source text even where the YAML 1.2 schema resolves it to a number, boolean, or null: password: 123456 gives "123456", ~ gives "~", an empty value gives "". Off by default: a String field refuses a non-string plain scalar. Quoted scalars are strings either way. Matches what serde_yaml did for typed targets.

legacy_sexagesimal: bool

When true, accept YAML 1.1-style sexagesimal numbers (60:00, 1:30:00) as integers. The colon-separated digits are interpreted in base 60: each component is multiplied by an increasing power of 60, summed left to right. 60:00 → 3 600; 1:30:00 → 5 400. Negative values (-1:30:00) and partial signs are honoured.

Off by default to honour the YAML 1.2 schema. Useful for migrations from YAML 1.1 / Ruby / pyyaml configs that use the legacy time-of-day notation.

lossless_u64_integers: bool

When true, and the lossless-u64 Cargo feature is enabled, YAML integer scalars in (i64::MAX, u64::MAX] resolve as unsigned integers instead of falling through to f64.

Default false to preserve the historical public Integer(i64) / Float(f64) model and serde-yaml compatibility.

leading_zero_integer_strings: bool

When true, a plain decimal integer with a leading zero (0123, +007) resolves as a string instead of a number. This is what serde_yaml 0.9 (libyaml) did — the spelling is octal in YAML 1.1 and decimal in 1.2, and libyaml sidestepped the ambiguity by resolving neither. 0, 0o755, and 0x1F are unaffected. Default false (YAML 1.2: a decimal integer).

legacy_binary_numbers: bool

When true, accept YAML 1.1-style binary literals (0b11 → 3). Default false to honour the YAML 1.2 schema, which has no binary form.

float_overflow_strings: bool

When true, a plain scalar float whose literal spelling overflows f64 (1e999) resolves as a string instead of infinity. The explicit spellings .inf / -.Inf / .nan still resolve to their float values. Matches serde_yaml 0.9. Default false (overflow saturates to infinity, the Rust float-parsing convention).

integer_overflow_errors: bool

When true, a plain decimal integer beyond u64::MAX (18446744073709551616) aborts the parse with ErrorKind::IntegerOverflow instead of falling through to an approximate f64. Matches serde_yaml 0.9’s “JSON number out of range”. Default false.

non_scalar_key_policy: NonScalarKeyPolicy

What to do with a non-scalar mapping key ([a, b]: v, {k: v}: w). See NonScalarKeyPolicy. Default NonScalarKeyPolicy::Stringify — the key is converted to its deterministic string form.

alias_jump_event_factor: Option<usize>

Transitive alias-expansion budget as a multiple of the document’s own event count, mirroring serde_yaml 0.9’s rule (its deserializer refuses once alias jumps exceed events × 100 with “repetition limit exceeded”). Each alias expansion charges the full node count of the anchored subtree, so nested anchors multiply. None (default) disables the factor check; the absolute Self::max_alias_expansions and byte budgets still apply.

require_indent: RequireIndent

Indentation-validation mode. See RequireIndent. Default: RequireIndent::Unchecked — accept any well-formed YAML indent.

policies: Vec<Arc<dyn Policy>>

Pluggable “Safe YAML” policies, run during parsing.

Each Policy inspects parser events and the post-parse Value tree; any policy returning Err(...) aborts the parse with that diagnostic. Empty by default.

Use ParserConfig::with_policy to register a policy. When at least one policy is present the streaming fast-path is bypassed automatically so the policy contract holds for every code path.

properties: Option<Arc<HashMap<String, String>>>

${KEY} / ${KEY:-default} substitution table consulted after parsing every document.

Each scalar in the resulting Value tree is walked and any ${name} placeholder is replaced with the property of that name. Supported syntax:

• ${name} — substitute, error or pass through depending on Self::strict_properties
• ${name:-default} — substitute, falling back to default when name is missing (always silent, never surfaces in errors)
• ${{ — literal ${ (escape for the open delimiter)
• $$ — literal $
• }} — literal }

None (default) disables the substitution pass entirely; the parser is unchanged. Setting a non-empty map forces the AST fallback so the post-parse walk runs uniformly across every typed target.

strict_properties: bool

When true, an unknown ${name} placeholder (no entry in Self::properties and no :-default fallback) aborts the parse with Error::Custom. When false (default), unknown placeholders are replaced with the empty string — the lossy semantics matching Value::interpolate_properties_lossy.

include_resolver: Option<IncludeResolver>

!include directive resolver. When set, the post-parse walk substitutes every Value::Tagged(!include, spec) node with the result of resolver(IncludeRequest). See crate::include::IncludeResolver for the closure signature and crate::include::SafeFileResolver for the bundled filesystem implementation.

None (default) disables include expansion; tagged !include nodes flow through unchanged.

max_include_depth: usize

Maximum !include recursion depth. Default 24. Each nested !include increments the depth counter; once the limit is reached, the parser aborts with Error::RecursionLimitExceeded. Pairs with a per-walk visited-set to catch cycles independent of depth.

max_include_sources: usize

Maximum number of sources resolved during one include walk. Default 256.

max_total_include_bytes: usize

Maximum cumulative bytes returned by include resolvers during one include walk. Default 64 MiB.

Implementations

impl ParserConfig

pub fn new() -> Self

Create a new configuration with default values.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new();
assert_eq!(cfg.max_depth, 128);

pub fn profile(profile: ParserProfile) -> Self

Create a configuration from a stable named profile.

Profiles make trust-boundary configuration explicit and keep callers independent from the individual fields that compose each baseline. Builder methods can refine the returned configuration.

Examples

use noyalib::{ParserConfig, ParserProfile};

let cfg = ParserConfig::profile(ParserProfile::Strict)
    .max_document_length(32 * 1024);
assert_eq!(cfg.max_document_length, 32 * 1024);

pub fn strict() -> Self

Create a strict configuration (YAML 1.2 strict) with tighter security limits suitable for untrusted input.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::strict();
assert_eq!(cfg.max_depth, 64);

pub fn serde_yaml_compat() -> Self

Create the configuration the compat-serde-yaml shim uses: noyalib’s defaults with every knob turned to reproduce serde_yaml 0.9’s observable behaviour on the same input — the behavioural half of being a drop-in replacement.

Concretely, relative to ParserConfig::new:

• << merge keys stay ordinary entries whose alias values resolve (MergeKeyPolicy::AsOrdinary) — serde_yaml never implemented the merge;
• leading-zero integers (0123) resolve as strings and YAML 1.1 binary literals (0b11) as integers — libyaml’s resolver, spec versions notwithstanding;
• a literal float overflow (1e999) is a string, not infinity;
• integers past u64::MAX error (“JSON number out of range” territory) instead of degrading to f64, and (with the lossless-u64 feature the shim enables) u64-range integers keep full precision;
• a non-scalar mapping key is an error, not a stringified key;
• transitive alias expansion is budgeted at 100× the document’s event count — the exact rule behind serde_yaml’s “repetition limit exceeded”.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::serde_yaml_compat();
assert!(cfg.leading_zero_integer_strings);
assert_eq!(cfg.alias_jump_event_factor, Some(100));

pub fn limits(&self) -> ParserLimits

Return the resource budgets currently applied to this configuration.

Semantic settings, policies, property interpolation, tag registries, and include resolvers are deliberately excluded.

pub fn with_limits(self, limits: ParserLimits) -> Self

Replace every resource budget while preserving semantic settings and installed integrations.

Examples

use noyalib::{ParserConfig, ParserLimits, YamlVersion};

let cfg = ParserConfig::new()
    .version(YamlVersion::V1_1)
    .with_limits(ParserLimits::strict());
assert_eq!(cfg.yaml_version, YamlVersion::V1_1);
assert_eq!(cfg.max_depth, 64);

pub fn properties(self, properties: Arc<HashMap<String, String>>) -> Self

Install a ${KEY} substitution table consulted after parsing.

Each scalar in the resulting Value tree is walked and any ${name} placeholder is replaced with the property of that name. Pairs with Self::strict_properties to choose between erroring or silently empty-substituting on unknown keys, and with ${name:-default} syntax for inline defaults.

Examples

use noyalib::{from_str_with_config, ParserConfig, Value};
use std::collections::HashMap;
use std::sync::Arc;

let mut props = HashMap::new();
props.insert("HOST".to_string(), "localhost".to_string());
let cfg = ParserConfig::new().properties(Arc::new(props));
let v: Value = from_str_with_config("url: http://${HOST}/", &cfg).unwrap();
assert_eq!(v["url"].as_str(), Some("http://localhost/"));

pub fn strict_properties(self, strict: bool) -> Self

Toggle strict-mode placeholder resolution.

When true, an unknown ${name} (no map entry, no :-default fallback) aborts the parse. When false (default), unknown placeholders are replaced with the empty string — useful for environment-style configs where missing variables should silently degrade.

Examples

use noyalib::{from_str_with_config, ParserConfig, Value};
use std::collections::HashMap;
use std::sync::Arc;

let cfg = ParserConfig::new()
    .properties(Arc::new(HashMap::new()))
    .strict_properties(true);
let res: Result<Value, _> = from_str_with_config("x: ${MISSING}", &cfg);
assert!(res.is_err());

pub fn include_resolver(self, resolver: IncludeResolver) -> Self

Install an !include directive resolver.

Each Value::Tagged(!include, scalar_spec) node in the parsed tree is replaced with the resolver’s output. The resolver is consulted with an IncludeRequest carrying the verbatim spec text, a stable source-id, and the current recursion depth.

Pair with Self::max_include_depth to bound the recursion ceiling. Cycle detection (A includes B includes A) runs independently using a per-walk visited set.

Examples

use noyalib::include::{IncludeRequest, IncludeResolver, InputSource};
use noyalib::{ParserConfig, Result};

let resolver = IncludeResolver::new(|req: IncludeRequest<'_>| -> Result<InputSource> {
    // For an in-memory test, fabricate a YAML payload
    // keyed on the spec.
    Ok(InputSource::new(req.spec, format!("name: {}\n", req.spec)))
});
let cfg = ParserConfig::new().include_resolver(resolver);

pub fn max_include_depth(self, depth: usize) -> Self

Maximum !include recursion depth.

Default 24 (8 in Self::strict()). Each nested !include increments the depth; once the limit is reached, the parser aborts with Error::RecursionLimitExceeded. The cap is independent of Self::max_depth (which bounds YAML structural nesting) and of the per-walk cycle-detection set (which catches A→B→A regardless of depth).

pub fn max_include_sources(self, max: usize) -> Self

Set the maximum number of sources resolved by one include walk.

pub fn max_total_include_bytes(self, max: usize) -> Self

Set the cumulative byte budget for sources returned by include resolvers.

pub fn version(self, version: YamlVersion) -> Self

Select the YAML specification version the resolver should honour.

Selecting YamlVersion::V1_1 is a preset over the three legacy_* flags — equivalent to:

cfg.legacy_booleans      = true;  // yes / no / on / off
cfg.legacy_octal_numbers = true;  // 0644 → octal
cfg.legacy_sexagesimal   = true;  // 60:00 → 3600

Selecting YamlVersion::V1_2 resets those three flags to false so callers can revert to strict 1.2 mode without re-creating the config from scratch. Other fields (limits, policies, merge-key behaviour) are unaffected.

Fine-grained overrides (e.g. “1.1 booleans but reject octal 0644”) work as expected: call version first, then flip individual flags.

Examples

use noyalib::{from_str_with_config, ParserConfig, Value, YamlVersion};

let cfg = ParserConfig::new().version(YamlVersion::V1_1);
// YAML 1.1 booleans
let v: Value = from_str_with_config("on", &cfg).unwrap();
assert_eq!(v, Value::Bool(true));
// YAML 1.1 octal
let v: Value = from_str_with_config("0644", &cfg).unwrap();
assert_eq!(v, Value::from(420_i64));
// YAML 1.1 sexagesimal
let v: Value = from_str_with_config("1:30", &cfg).unwrap();
assert_eq!(v, Value::from(90_i64));

pub fn with_policy<P>(self, policy: P) -> Self

where P: Policy + 'static,

Register a Policy to enforce during parsing.

Multiple policies may be registered; they all run in registration order, and the first error short-circuits the parse. When any policy is present the streaming fast-path is bypassed so the policy contract is enforced uniformly.

Examples

use noyalib::{from_str_with_config, ParserConfig, Value};
use noyalib::policy::DenyAnchors;

let cfg = ParserConfig::new().with_policy(DenyAnchors);
let res: Result<Value, _> =
    from_str_with_config("a: &x 1\nb: *x\n", &cfg);
assert!(res.is_err());

pub fn max_depth(self, depth: usize) -> Self

Set the maximum recursion depth.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_depth(32);
assert_eq!(cfg.max_depth, 32);

pub fn max_document_length(self, len: usize) -> Self

Set the maximum document length.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_document_length(1024);
assert_eq!(cfg.max_document_length, 1024);

pub fn max_alias_expansions(self, expansions: usize) -> Self

Set the maximum alias expansions.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_alias_expansions(50);
assert_eq!(cfg.max_alias_expansions, 50);

pub fn max_mapping_keys(self, max: usize) -> Self

Set the maximum number of mapping keys.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_mapping_keys(100);
assert_eq!(cfg.max_mapping_keys, 100);

pub fn max_sequence_length(self, max: usize) -> Self

Set the maximum sequence length.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_sequence_length(100);
assert_eq!(cfg.max_sequence_length, 100);

pub fn max_events(self, max: usize) -> Self

Set the maximum total parser-event budget.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_events(50_000);
assert_eq!(cfg.max_events, 50_000);

pub fn max_nodes(self, max: usize) -> Self

Set the maximum total Value node budget.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_nodes(10_000);
assert_eq!(cfg.max_nodes, 10_000);

pub fn max_total_scalar_bytes(self, max: usize) -> Self

Set the maximum cumulative scalar-byte budget.

Distinct from Self::max_document_length — this caps scalar bytes after alias expansion.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_total_scalar_bytes(8 * 1024 * 1024);
assert_eq!(cfg.max_total_scalar_bytes, 8 * 1024 * 1024);

pub fn max_documents(self, max: usize) -> Self

Set the maximum document count for multi-document streams.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_documents(64);
assert_eq!(cfg.max_documents, 64);

pub fn max_stream_bytes(self, max: usize) -> Self

Set the maximum total byte length of a multi-document stream.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_stream_bytes(8 * 1024 * 1024);
assert_eq!(cfg.max_stream_bytes, 8 * 1024 * 1024);

pub fn max_merge_keys(self, max: usize) -> Self

Set the maximum merge-key count budget.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().max_merge_keys(1_000);
assert_eq!(cfg.max_merge_keys, 1_000);

pub fn require_indent(self, mode: RequireIndent) -> Self

Set the indentation-validation mode.

Examples

use noyalib::{ParserConfig, RequireIndent};
let cfg = ParserConfig::new().require_indent(RequireIndent::Even);
assert_eq!(cfg.require_indent, RequireIndent::Even);

pub fn alias_anchor_ratio(self, ratio: Option<f64>) -> Self

Set the alias-to-anchor ratio heuristic.

Pass Some(ratio) to enable the billion-laughs guard, None to disable.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().alias_anchor_ratio(Some(20.0));
assert_eq!(cfg.alias_anchor_ratio, Some(20.0));

pub fn duplicate_key_policy(self, policy: DuplicateKeyPolicy) -> Self

Set the duplicate key policy.

Examples

use noyalib::{DuplicateKeyPolicy, ParserConfig};
let cfg = ParserConfig::new().duplicate_key_policy(DuplicateKeyPolicy::Error);
assert_eq!(cfg.duplicate_key_policy, DuplicateKeyPolicy::Error);

pub fn strict_booleans(self, strict: bool) -> Self

Enable or disable strict booleans.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().strict_booleans(true);
assert!(cfg.strict_booleans);

pub fn legacy_booleans(self, legacy: bool) -> Self

Enable or disable legacy booleans.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().legacy_booleans(true);
assert!(cfg.legacy_booleans);

pub fn tag_registry(self, registry: Arc<TagRegistry>) -> Self

Attach a TagRegistry so the streaming deserializer strips listed custom tags instead of routing them through the AST.

See the tag_registry module documentation for when to use this versus #[serde(rename)].

Examples

use noyalib::{ParserConfig, TagRegistry};
use std::sync::Arc;
let reg = Arc::new(TagRegistry::new().with("!Celsius"));
let cfg = ParserConfig::new().tag_registry(Arc::clone(&reg));
assert!(cfg.tag_registry.is_some());

pub fn merge_key_policy(self, policy: MergeKeyPolicy) -> Self

Set the policy for handling the YAML merge key (<<).

Examples

use noyalib::{MergeKeyPolicy, ParserConfig};
let cfg = ParserConfig::new().merge_key_policy(MergeKeyPolicy::AsOrdinary);
assert_eq!(cfg.merge_key_policy, MergeKeyPolicy::AsOrdinary);

pub fn no_schema(self, no_schema: bool) -> Self

Toggle schema-free plain-scalar resolution. When true, every plain scalar becomes a string regardless of whether it would normally resolve to null, bool, integer, or float.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().no_schema(true);
assert!(cfg.no_schema);

pub fn legacy_octal_numbers(self, on: bool) -> Self

Toggle YAML 1.1-style bare 0-prefix octal parsing (e.g. 0644 → 420). Off by default; YAML 1.2 requires the 0o prefix.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().legacy_octal_numbers(true);
assert!(cfg.legacy_octal_numbers);

pub fn ignore_binary_tag_for_string(self, on: bool) -> Self

Toggle the migration-helper behaviour where !!binary "ABCD" deserializes into a String target as the literal base64 source string. The canonical bytes path (Vec<u8>, serde_bytes::ByteBuf) is unaffected — it always decodes the base64 payload.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().ignore_binary_tag_for_string(true);
assert!(cfg.ignore_binary_tag_for_string);

pub fn plain_scalar_strings(self, on: bool) -> Self

When enabled, a plain scalar deserializes into a String (or char) target as its source text even where the YAML 1.2 schema resolves it to a number, boolean, or null: password: 123456 gives "123456", ~ gives "~", an empty value gives "". Off by default: a String field refuses a non-string plain scalar. Quoted scalars are strings either way. Matches what serde_yaml did for typed targets.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().plain_scalar_strings(true);
assert!(cfg.plain_scalar_strings);

pub fn legacy_sexagesimal(self, on: bool) -> Self

Toggle YAML 1.1-style sexagesimal number parsing (60:00 → 3 600). Off by default; YAML 1.2 dropped the sexagesimal schema, so plain 1:30:00 would otherwise surface as a string.

Examples

use noyalib::ParserConfig;
let cfg = ParserConfig::new().legacy_sexagesimal(true);
assert!(cfg.legacy_sexagesimal);

pub fn lossless_u64_integers(self, on: bool) -> Self

Enable or disable lossless unsigned integer resolution.

With the lossless-u64 feature enabled, setting this to true lets YAML integer scalars in (i64::MAX, u64::MAX] resolve as Number::Unsigned instead of falling through to Number::Float.

Trait Implementations

impl Clone for ParserConfig

fn clone(&self) -> ParserConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParserConfig

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

Formats the value using the given formatter.

impl Default for ParserConfig

fn default() -> Self

Returns the “default value” for a type.