Struct ValidationSession 

pub struct ValidationSession { /* private fields */ }

Stateful two-phase validation harness for callers (like the loader) that need to interleave validation with other pipeline steps.

Typical use: run run_phase with Phase::Early AFTER plugins but BEFORE booking, then Phase::Late AFTER booking. Call finalize at the end to flush deferred checks (e.g., unused pads).

Standalone callers that don’t run booking between phases (e.g. LSP, FFI, tests) run the three calls back-to-back against the same directive list. The verbosity is intentional — it surfaces the phase split so callers explicitly choose whether to interleave booking between Early and Late.

Migration from pre-#1116

The free-function shortcuts validate, validate_with_options, validate_with_today, validate_spanned_with_options, and validate_spanned_with_today were removed. Replace each call site with the three-step ValidationSession sequence shown below.

Preconditions

Each session is single-use:

• Call Phase::Early at most once.
• Call Phase::Late at most once, and only AFTER Early.
• Call finalize at most once, and only AFTER both phases.

In debug builds, violating this contract panics. In release builds the duplicate / out-of-order call is a no-op that returns an empty error list — this is deliberate so a buggy caller can’t silently corrupt the shared LedgerState (inventories are additive, so a second Late pass would double-book every transaction).

Example

use rustledger_validate::{Phase, ValidationOptions, ValidationSession};
use rustledger_core::{Directive, naive_date};

let directives: Vec<Directive> = vec![];
let today = naive_date(2030, 1, 1).unwrap();

let mut session = ValidationSession::new(ValidationOptions::default());
let mut errors = session.run_phase(&directives, Phase::Early, today);
// ... booking runs here; plugins ran BEFORE Early ...
errors.extend(session.run_phase(&directives, Phase::Late, today));
errors.extend(session.finalize());

Implementations

impl ValidationSession

pub fn new(options: ValidationOptions) -> Self

Create a new session with the given validation options.

pub fn run_phase( &mut self, directives: &[Directive], phase: Phase, today: NaiveDate, ) -> Vec<ValidationError>

Run one validation phase over a slice of raw Directives.

Early runs account/structural checks that don’t need filled-in amounts. Late runs balance/inventory/currency checks that do. The session’s internal LedgerState is updated by each phase so subsequent calls see the accumulated state.

Panics (debug only)

Panics in debug builds if called out of order — Phase::Late before Phase::Early, or either phase invoked twice. In release builds the offending call is a no-op returning an empty Vec. See the type-level “Preconditions” section.

pub fn run_phase_spanned( &mut self, directives: &[Spanned<Directive>], phase: Phase, today: NaiveDate, ) -> Vec<ValidationError>

Variant of run_phase for Spanned<Directive> slices. Preserves source-location info on emitted errors so callers (LSP, loader, FFI) can render file:line:column diagnostics directly.

Same phase-ordering preconditions as run_phase.

pub fn finalize(self) -> Vec<ValidationError>

Flush deferred end-of-validation checks. Currently emits unused pad warnings (E2003). Call once after both phases have run — dropping the returned Vec discards those warnings.

Consumes the session because deferred state is per-session; re-running finalize on the same state would re-emit the same errors.