Struct RequestOutcome 

pub struct RequestOutcome {
    pub status: RequestStatus,
    pub affects: RequestEffect,
    pub requested: String,
    pub scope_size: Option<u64>,
    pub reason: Option<String>,
    pub message: Option<String>,
}

One request’s fate on one run.

reason and message are present exactly when status is not applied, and absent otherwise, so a consumer that only wants to know whether a report is scoped reads status alone.

Fields

status: RequestStatus

What became of the request.

affects: RequestEffect

What this request governs, and therefore what an unapplied one means. Derived from the name, so the two can never disagree.

requested: String

What was asked, as the user spelled it: the git ref for changed-since, the diff source label (--diff-file pr.diff, --diff-stdin, $FALLOW_DIFF_FILE build/pr.diff, or diffFile pr.diff for the programmatic option) for diff-filter, workspaces.changedSince for package-baselines, the target path for sarif-file. Echoed rather than normalised, so a consumer must not join it to the project root the way it joins every other path-shaped field.

scope_size: Option<u64>

How much this request left in scope, in the request’s own unit, when the run applied it AND measured that scope. Absent otherwise, including on every unapplied entry: a request that stood down narrowed nothing, so a number there would describe a scope nobody applied.

The unit belongs to the name. diff-filter counts added lines, which is what its filter keeps a finding for. changed-since counts changed files that the run analyzed: a changed file that discovery or an ignore rule dropped does not count, so a change to a README only gives 0. A combined run counts a file that any of its analyses kept, because a per-analysis production setting can give its analyses different files. Read the unit off the name the entry is keyed under, never across names, and read an absent member as “not measured” rather than as zero.

The count is what the run INDEXED rather than the true total: diff-filter indexes at most one million added lines and reports that cap for a larger diff, so read any non-zero value as a lower bound.

0 is the case this member exists for: a request that applied over an EMPTY scope. Every finding then filters out and the report reads clean, so a consumer that sees no findings beside scope_size: 0 learns that nothing was analyzable rather than that the code is clean.

reason: Option<String>

Why the request was not applied, as a kebab-case token. Present exactly when status is not applied. The set is open per request name; the names this build can emit are listed on RequestOutcomes.

message: Option<String>

One sentence naming what was asked, what happened instead, and the next step. Byte-identical to the stderr line for the same case, so a consumer that renders this never contradicts a log a human read. Present exactly when status is not applied.

Implementations

impl RequestOutcome

pub fn applied(name: RequestName, requested: impl Into<String>) -> Self

A request the run honoured.

Takes the name rather than the class so no caller can file a request under the wrong one.

pub fn applied_with_scope_size( name: RequestName, requested: impl Into<String>, size: u64, ) -> Self

A request the run honoured, whose remaining scope it also measured.

size is in the unit RequestOutcome::scope_size documents for this name. Use Self::applied where the run applies a request without measuring what it left, so the member stays absent rather than claiming a zero nobody counted.

pub fn not_applied( name: RequestName, requested: impl Into<String>, reason: impl Into<String>, message: impl Into<String>, ) -> Self

A request the run could not honour, with the reason token and the sentence the CLI also wrote to stderr.

Trait Implementations

impl Clone for RequestOutcome

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RequestOutcome

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

Formats the value using the given formatter.

impl Eq for RequestOutcome

impl PartialEq for RequestOutcome

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RequestOutcome

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RequestOutcome