raz-validation 0.2.4

Smart options validation system for raz
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

//! Validation configuration and levels

use serde::{Deserialize, Serialize};

/// Configuration for validation behavior
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationConfig {
    /// Validation level
    pub level: ValidationLevel,

    /// Enabled providers
    pub providers: Vec<String>,

    /// Custom options for specific commands
    pub custom_options: std::collections::HashMap<String, Vec<CustomOption>>,

    /// Minimum similarity score for suggestions
    pub suggestion_threshold: i64,
}

impl Default for ValidationConfig {
    fn default() -> Self {
        Self {
            level: ValidationLevel::Normal,
            providers: vec!["cargo".to_string(), "leptos".to_string()],
            custom_options: std::collections::HashMap::new(),
            suggestion_threshold: 30,
        }
    }
}

/// Validation strictness levels
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ValidationLevel {
    /// No validation - allow any options
    Off,

    /// Minimal validation - only check known conflicts
    Minimal,

    /// Normal validation - validate known options, warn on unknown
    Normal,

    /// Strict validation - reject unknown options
    Strict,
}

impl ValidationLevel {
    /// Check if this level performs validation
    pub fn is_enabled(self) -> bool {
        !matches!(self, Self::Off)
    }

    /// Check if this level is strict
    pub fn is_strict(self) -> bool {
        matches!(self, Self::Strict)
    }

    /// Check if this level allows unknown options
    pub fn allows_unknown(self) -> bool {
        matches!(self, Self::Off | Self::Minimal | Self::Normal)
    }
}

/// Custom option definition for configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CustomOption {
    /// Option name
    pub name: String,

    /// Option type
    #[serde(rename = "type")]
    pub option_type: String,

    /// Description
    pub description: Option<String>,

    /// Valid values (for enum types)
    pub values: Option<Vec<String>>,

    /// Conflicts with these options
    pub conflicts_with: Option<Vec<String>>,

    /// Requires these options
    pub requires: Option<Vec<String>>,
}

impl ValidationConfig {
    /// Create a new config with specified level
    pub fn with_level(level: ValidationLevel) -> Self {
        Self {
            level,
            ..Default::default()
        }
    }

    /// Add a provider to the config
    pub fn add_provider(mut self, provider: impl Into<String>) -> Self {
        self.providers.push(provider.into());
        self
    }

    /// Set suggestion threshold
    pub fn with_suggestion_threshold(mut self, threshold: i64) -> Self {
        self.suggestion_threshold = threshold;
        self
    }

    /// Check if a provider is enabled
    pub fn is_provider_enabled(&self, provider: &str) -> bool {
        self.providers.contains(&provider.to_string())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_validation_level_methods() {
        assert!(ValidationLevel::Normal.is_enabled());
        assert!(!ValidationLevel::Off.is_enabled());

        assert!(ValidationLevel::Strict.is_strict());
        assert!(!ValidationLevel::Normal.is_strict());

        assert!(ValidationLevel::Normal.allows_unknown());
        assert!(!ValidationLevel::Strict.allows_unknown());
    }

    #[test]
    fn test_config_defaults() {
        let config = ValidationConfig::default();
        assert_eq!(config.level, ValidationLevel::Normal);
        assert!(config.providers.contains(&"cargo".to_string()));
    }

    #[test]
    fn test_config_builder() {
        let config = ValidationConfig::with_level(ValidationLevel::Strict)
            .add_provider("dioxus")
            .with_suggestion_threshold(50);

        assert_eq!(config.level, ValidationLevel::Strict);
        assert!(config.is_provider_enabled("dioxus"));
        assert_eq!(config.suggestion_threshold, 50);
    }
}