Enum ValidationResult 

pub enum ValidationResult {
    Success {
        metrics: ValidationMetrics,
        report: ValidationReport,
    },
    Failure {
        report: ValidationReport,
    },
}

The result of running a validation suite.

Variants

Success

Validation completed successfully with no critical issues

Fields

metrics: ValidationMetrics

Validation metrics

report: ValidationReport

Detailed report (may contain warnings or info)

Failure

Validation failed due to one or more critical issues

Fields

report: ValidationReport

Detailed report containing the issues

Implementations

impl ValidationResult

pub fn success(metrics: ValidationMetrics, report: ValidationReport) -> Self

Creates a successful validation result.

pub fn failure(report: ValidationReport) -> Self

Creates a failed validation result.

pub fn is_success(&self) -> bool

Returns true if the validation succeeded.

pub fn is_failure(&self) -> bool

Returns true if the validation failed.

pub fn report(&self) -> &ValidationReport

Returns the validation report.

pub fn metrics(&self) -> Option<&ValidationMetrics>

Returns the validation metrics if available (only for success).

pub fn to_json(&self) -> Result<String>

Formats the validation result as JSON.

This is a convenience method that uses the JsonFormatter to output the result as structured JSON.

Examples

let json_output = result.to_json().unwrap();
println!("{}", json_output);

pub fn to_json_pretty(&self) -> Result<String>

Formats the validation result as JSON with pretty printing.

Examples

let pretty_json = result.to_json_pretty().unwrap();
println!("{}", pretty_json);

pub fn to_human(&self) -> Result<String>

Formats the validation result in a human-readable format.

This is a convenience method that uses the HumanFormatter to output the result in a format suitable for console display.

Examples

let human_output = result.to_human().unwrap();
println!("{}", human_output);

pub fn to_markdown(&self) -> Result<String>

Formats the validation result as Markdown.

This is a convenience method that uses the MarkdownFormatter to output the result in Markdown format suitable for documentation.

Examples

let markdown_output = result.to_markdown().unwrap();
println!("{}", markdown_output);

pub fn format_with<F: ResultFormatter>(&self, formatter: &F) -> Result<String>

Formats the validation result using a custom formatter.

Arguments

• formatter - The formatter to use

Examples

use term_guard::formatters::{ResultFormatter, HumanFormatter, FormatterConfig};

let config = FormatterConfig::minimal();
let formatter = HumanFormatter::with_config(config);
let output = result.format_with(&formatter).unwrap();
println!("{}", output);

Trait Implementations

impl Clone for ValidationResult

fn clone(&self) -> ValidationResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ValidationResult

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ValidationResult

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ValidationResult

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

where __S: Serializer,

Serialize this value into the given Serde serializer.