Struct Plaintext 

pub struct Plaintext { /* private fields */ }

A leaf’s plaintext bytes, together with the type they render as.

No Display, no Deref<Target = str>, no AsRef<str>, no Into<String>, and a Debug that prints a length rather than content. Reading the bytes takes Plaintext::expose — deliberately one greppable token, so a review searches for a presence instead of noticing an absence. Same discipline as cofre_secret::Secret, applied to a value that arrives from a file rather than from an operator.

Implementations

impl Plaintext

pub fn from_wire(bytes: Vec<u8>, ty: LeafType) -> Self

Wrap bytes that are already the canonical rendering for ty.

Used on the decrypt path, where the bytes came out of GCM and the type came off the wire.

pub fn string(s: impl Into<String>) -> Self

A type:str leaf.

pub fn integer(v: i64) -> Self

A type:int leaf. Rendered by Go’s strconv.Itoa, which for the 64-bit int in play is just decimal — matching Rust’s i64 Display.

pub fn float(v: f64) -> Self

A type:float leaf.

Go uses strconv.FormatFloat(v, 'f', -1, 64): shortest representation that round-trips, never exponent notation, and — the comment in cipher.go says so outright — no zero padding after the point, because the Python implementation didn’t pad. Rust’s {} for f64 is also shortest-round-trip, but it will reach for exponent form on extreme magnitudes, so those are rendered positionally by hand.

pub fn boolean(v: bool) -> Self

A type:bool leaf. True/False — Python titlecase, as cipher.go notes explicitly. Writing Rust’s true/false here changes the MAC.

pub fn comment(body: impl Into<String>) -> Self

A type:comment leaf. The stored body excludes the leading #, which the YAML store strips with commentLine[1:].

pub fn leaf_type(&self) -> LeafType

The declared type.

pub fn len(&self) -> usize

Length in bytes. Safe to log; it is what Debug prints.

pub fn is_empty(&self) -> bool

Whether the value is empty — which the format treats as a fixed point in both directions (see EncryptedLeaf::render).

pub fn expose(&self) -> &[u8]

The plaintext bytes. Named to be searched for.

pub fn mac_bytes(&self) -> &[u8]

The bytes this leaf contributes to the MAC.

sops.ToBytes over the plaintext, which for every type we can emit is the same canonical rendering already held here — so this is the identity. It exists as a named method anyway, because the MAC contribution and the stored bytes are conceptually two different questions and a future type could separate them.

pub fn validate(&self) -> Result<(), WireError>

Check the bytes really are a valid rendering of the declared type.

Not called on the hot decrypt path — sops does not validate either, and a file it accepts must not be one we reject. Offered for filestatus-style inspection and for tests.

Trait Implementations

impl Clone for Plaintext

fn clone(&self) -> Plaintext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Plaintext

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

Formats the value using the given formatter.

impl Eq for Plaintext

impl PartialEq for Plaintext

fn eq(&self, other: &Self) -> bool

Constant-time in the bytes.

A plaintext comparison is a secret comparison — the obvious place it happens is “did this value change?” during an edit, where a timing signal leaks a prefix length. Length and type are not secret (the length ships in the ciphertext), so short-circuiting on those leaks nothing and keeps the byte compare well-defined.

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

Inequality operator !=.