Struct AdoptReport 

pub struct AdoptReport {
    pub adopted: Vec<PathBuf>,
    pub already_owned: Vec<PathBuf>,
    pub converged: Vec<PathBuf>,
    pub skipped_drifted: Vec<PathBuf>,
    pub skipped_create_once: Vec<PathBuf>,
    pub recorded_unstampable: Vec<PathBuf>,
    pub unreadable: Vec<PathBuf>,
    pub diffs: Vec<AdoptDiff>,
    pub preview: bool,
}

Fields

adopted: Vec<PathBuf>

Paths whose marker (or durable ownership record) was actually written. Always empty when write was false.

already_owned: Vec<PathBuf>

Paths that already carried a marker; no diff is produced for these.

converged: Vec<PathBuf>

Matches whose bytes already equal this run’s output apart from the marker.

Reported as a set of paths rather than as Self::diffs entries: their diff is the file echoed back, so a per-file read buys the reader nothing and at consumer-repo scale actively buries the drifted diffs that do matter. ~keep

skipped_drifted: Vec<PathBuf>

Drifted matches left untouched because AdoptOptions::converged_only was set.

skipped_create_once: Vec<PathBuf>

Create-once seeds excluded because AdoptOptions::clobber_create_once_seeds was not set, in path order.

A Vec of paths rather than a count, and reported even in preview: these are the matches where adoption is destructive, so the operator has to be able to read the list and recognise a file as their own before deciding. A count tells them only that something was excluded, which is exactly the fact that does not help. ~keep

recorded_unstampable: Vec<PathBuf>

Paths adopted through the committed .alef-ownership.toml record because their format cannot carry a marker at all. Reported separately from Self::adopted because adopting these leaves the file itself byte-identical: the consent lives in a different file, which the operator has to commit for the adoption to mean anything anywhere else. ~keep

unreadable: Vec<PathBuf>

Matches alef can make no statement about at all, in path order.

Two shapes reach this list, and both are alef failing rather than the operator having a decision to make: bytes that are not valid UTF-8 on a path alef does not emit as binary, and a [crate::cli::pipeline::is_base64_binary_output] path whose generated content did not decode as base64. Skipped rather than adopted, and reported rather than dropped – one such file used to abort the entire target: a single gradle-wrapper.jar inside packages/** ended the run with “stream did not contain valid UTF-8” before any of the hundreds of adoptable text files beside it were stamped.

A jar is no longer one of them. It is classified on its decoded bytes and adopted through the ownership record like any other unstampable format – see BinaryFacts for why refusing it was wrong. ~keep

diffs: Vec<AdoptDiff>

Full, untruncated diffs for every drifted candidate, in path order.

preview: bool

True when this was a preview; nothing on disk was touched.

Implementations

impl AdoptReport

pub fn drifted(&self) -> impl Iterator<Item = &AdoptDiff> + '_

Trait Implementations

impl Debug for AdoptReport

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

Formats the value using the given formatter.

impl Default for AdoptReport

fn default() -> AdoptReport

Returns the “default value” for a type.