Struct SecretsSidecar 

pub struct SecretsSidecar {
    pub version: u32,
    pub secret_line_ranges: Vec<SecretLineRange>,
}

Per-file secrets sidecar — the on-disk shape of secret_line_ranges.

Schema is intentionally minimal: a version field and the slice of SecretLineRange entries the preprocessor emitted on the last successful render. Stored next to the baseline as <filename>.secret.json. See secrets.lex §3.3.

No baseline migration: this file is purely additive. Pre-secrets renders simply have no sidecar, which the load path treats as secret_line_ranges = [] (empty mask, byte-equivalent to legacy reverse-merge behaviour).

Fields

version: u32

Schema version. Bumps independently of the baseline schema — they’re separate files with separate evolution paths.

secret_line_ranges: Vec<SecretLineRange>

Line ranges produced on the last successful render. Empty when the file’s template renders without secrets (an explicit empty-array sidecar is fine; absence of the file is also fine and means the same thing).

Implementations

impl SecretsSidecar

pub fn new(ranges: Vec<SecretLineRange>) -> Self

Build a sidecar from a slice of line ranges.

pub fn write( &self, fs: &dyn Fs, paths: &dyn Pather, pack: &str, handler: &str, filename: &str, ) -> Result<Option<PathBuf>>

Persist the sidecar next to its baseline. Path layout matches Pather::preprocessor_secrets_sidecar_path. Creates parent directories as needed (in practice the baseline write that runs first has already created them, but write is robust to being called in either order). Overwrites any existing file.

When self.secret_line_ranges is empty, this is a no-op: callers don’t need to special-case “no secrets” — they always call write with whatever the renderer emitted, and the no-secrets case skips the disk write rather than dropping a { "secret_line_ranges": [] } file. Removes any existing sidecar in that case so a previous render’s secrets don’t linger after the user removes them from the template.

pub fn load( fs: &dyn Fs, paths: &dyn Pather, pack: &str, handler: &str, filename: &str, ) -> Result<Option<Self>>

Load the sidecar for a file. Returns Ok(None) when no sidecar exists — the documented “no secrets” state per §3.3. Errors on parse failure or unsupported version so the caller can suggest a dodot up --force re-render.

Trait Implementations

impl Clone for SecretsSidecar

fn clone(&self) -> SecretsSidecar

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SecretsSidecar

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SecretsSidecar

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SecretsSidecar

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SecretsSidecar

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SecretsSidecar

impl StructuralPartialEq for SecretsSidecar