Enum Path 

pub enum Path<'a> {
    Root,
    Seq {
        parent: &'a Path<'a>,
        index: usize,
    },
    Map {
        parent: &'a Path<'a>,
        key: &'a str,
    },
    Alias {
        parent: &'a Path<'a>,
    },
    Unknown {
        parent: &'a Path<'a>,
    },
}

Represents a path to a location within a YAML document structure.

Path is a recursive data structure that tracks the navigation path from the root of a YAML document to a specific value. It’s used to provide context in error messages, helping users understand exactly where in their YAML an issue occurred.

Variants

• Root: The root of the document
• Seq: An index into a sequence (array)
• Map: A key in a mapping (object)
• Alias: Following an alias reference
• Unknown: Unknown or unspecified location

Examples

use noyalib::Path;

// Building a path: servers[0].host
let root = Path::Root;
let servers = Path::Map {
    parent: &root,
    key: "servers",
};
let first = Path::Seq {
    parent: &servers,
    index: 0,
};
let host = Path::Map {
    parent: &first,
    key: "host",
};

assert_eq!(host.to_string(), "servers[0].host");

Variants

Root

The root of the document.

This is the starting point for all paths. When displayed, it shows as ..

Seq

An index into a sequence (array).

Fields

• parent: The path to the sequence containing this element
• index: The zero-based index into the sequence

Fields

parent: &'a Path<'a>

The parent path (the sequence itself).

index: usize

The index within the sequence (zero-based).

Map

A key in a mapping (object).

Fields

• parent: The path to the mapping containing this key
• key: The key name

Fields

parent: &'a Path<'a>

The parent path (the mapping itself).

key: &'a str

The key within the mapping.

Alias

Following an alias reference.

This variant is used when traversing through a YAML alias (*anchor) to indicate the path continues through an alias.

Fields

parent: &'a Path<'a>

The parent path before the alias.

Unknown

Unknown or unspecified location.

This variant is used when the exact location cannot be determined but we still want to track that we’re somewhere nested.

Fields

parent: &'a Path<'a>

The parent path.

Implementations

impl<'a> Path<'a>

pub fn index(&'a self, index: usize) -> Path<'a>

Creates a new sequence index path.

Examples

use noyalib::Path;

let root = Path::Root;
let items = Path::Map {
    parent: &root,
    key: "items",
};
let first = items.index(0);

assert_eq!(first.to_string(), "items[0]");

pub fn key(&'a self, key: &'a str) -> Path<'a>

Creates a new map key path.

Examples

use noyalib::Path;

let root = Path::Root;
let config = root.key("config");
let host = config.key("host");

assert_eq!(host.to_string(), "config.host");

pub fn alias(&'a self) -> Path<'a>

Creates a new alias path.

Examples

use noyalib::Path;

let root = Path::Root;
let alias_path = root.alias();

pub fn unknown(&'a self) -> Path<'a>

Creates a new unknown path.

pub fn is_root(&self) -> bool

Returns true if this is the root path.

Examples

use noyalib::Path;

let root = Path::Root;
assert!(root.is_root());

let child = root.key("test");
assert!(!child.is_root());

pub fn parent(&self) -> Option<&Path<'a>>

Returns the parent path, if any.

Returns None if this is the root path.

Examples

use noyalib::Path;

let root = Path::Root;
let child = root.key("test");

assert!(root.parent().is_none());
assert!(child.parent().is_some());

pub fn depth(&self) -> usize

Returns the depth of this path (number of segments from root).

Examples

use noyalib::Path;

let root = Path::Root;
assert_eq!(root.depth(), 0);

let child = root.key("a").key("b");
// Note: each key() creates a new path on the stack

Trait Implementations

impl<'a> Clone for Path<'a>

fn clone(&self) -> Path<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Path<'a>

impl<'a> Debug for Path<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Path<'a>

fn default() -> Path<'a>

Returns the “default value” for a type.

impl Display for Path<'_>

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

Formats the value using the given formatter.

impl<'a> Eq for Path<'a>

impl<'a> PartialEq for Path<'a>

fn eq(&self, other: &Path<'a>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> StructuralPartialEq for Path<'a>