mrapids 0.1.31

Your OpenAPI, but executable
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

/// Validation report that aggregates results from multiple validators
use super::types::{ValidationError, ValidationResult};
use super::version::SpecVersion;
use colored::*;
use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Complete validation report
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationReport {
    /// Detected spec version
    pub spec_version: SpecVersion,

    /// Validation results
    #[serde(flatten)]
    pub results: ValidationResult,

    /// Time taken to validate
    pub duration: Duration,

    /// Validation levels that were run
    pub levels_checked: Vec<String>,
}

impl ValidationReport {
    pub fn new(spec_version: SpecVersion) -> Self {
        Self {
            spec_version,
            results: ValidationResult::new(),
            duration: Duration::from_secs(0),
            levels_checked: Vec::new(),
        }
    }

    /// Check if the spec is valid (no errors)
    pub fn is_valid(&self) -> bool {
        self.results.is_valid()
    }

    /// Check if there are any warnings
    pub fn has_warnings(&self) -> bool {
        self.results.has_warnings()
    }

    /// Get error count
    pub fn error_count(&self) -> usize {
        self.results.error_count()
    }

    /// Get warning count
    pub fn warning_count(&self) -> usize {
        self.results.warning_count()
    }

    /// Get all errors
    pub fn errors(&self) -> &[ValidationError] {
        &self.results.errors
    }

    /// Get all warnings
    pub fn warnings(&self) -> &[ValidationError] {
        &self.results.warnings
    }

    /// Merge another validation result into this report
    pub fn merge_results(&mut self, results: ValidationResult) {
        self.results.merge(results);
    }

    /// Display the report with colors
    pub fn display(&self) {
        println!("🔍 {} Validation Report", "OpenAPI".bright_cyan());
        println!(
            "📋 Version: {}",
            self.spec_version.to_string().bright_blue()
        );
        println!("⏱ī¸  Duration: {}ms", self.duration.as_millis());
        println!("📊 Levels checked: {}", self.levels_checked.join(", "));
        println!();

        if self.is_valid() && !self.has_warnings() {
            println!("{} Specification is valid!", "✅".green());
            return;
        }

        // Display errors
        if !self.results.errors.is_empty() {
            println!("{} {} found:", "❌".red(), "Errors".red());
            for error in &self.results.errors {
                println!("  {} {}", "â€ĸ".red(), error.message);
                if let Some(path) = &error.path {
                    println!("    {} {}", "at".dimmed(), path.dimmed());
                }
                if let Some(line) = error.line {
                    println!(
                        "    {} line {}, column {}",
                        "at".dimmed(),
                        line.to_string().dimmed(),
                        error.column.unwrap_or(0).to_string().dimmed()
                    );
                }
            }
            println!();
        }

        // Display warnings
        if !self.results.warnings.is_empty() {
            println!("{} {} found:", "⚠ī¸".yellow(), "Warnings".yellow());
            for warning in &self.results.warnings {
                println!("  {} {}", "â€ĸ".yellow(), warning.message);
                if let Some(path) = &warning.path {
                    println!("    {} {}", "at".dimmed(), path.dimmed());
                }
            }
            println!();
        }

        // Display info
        if !self.results.info.is_empty() {
            println!("{} {} found:", "ℹī¸".blue(), "Information".blue());
            for info in &self.results.info {
                println!("  {} {}", "â€ĸ".blue(), info.message);
                if let Some(path) = &info.path {
                    println!("    {} {}", "at".dimmed(), path.dimmed());
                }
            }
            println!();
        }

        // Summary
        let error_text = if self.error_count() == 1 {
            "error"
        } else {
            "errors"
        };
        let warning_text = if self.warning_count() == 1 {
            "warning"
        } else {
            "warnings"
        };

        println!(
            "📈 Summary: {} {}, {} {}",
            self.error_count().to_string().red(),
            error_text,
            self.warning_count().to_string().yellow(),
            warning_text
        );
    }
}