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

use raz_validation::{ValidationConfig, ValidationEngine, ValidationLevel};

fn main() {
    println!("=== Raz Validation System Demo ===\n");

    // Create validation engine with default config
    let engine = ValidationEngine::new();

    // Test cargo options
    println!("🚀 Testing Cargo Options:");
    test_option(&engine, "build", "--release", None);
    test_option(
        &engine,
        "build",
        "--target",
        Some("x86_64-unknown-linux-gnu"),
    );
    test_option(&engine, "build", "--features", Some("serde,tokio"));
    test_option(&engine, "build", "--unknown-option", None);
    println!();

    // Test leptos options
    println!("🎯 Testing Leptos Options:");
    test_option(&engine, "leptos build", "--bin-features", Some("ssr"));
    test_option(&engine, "leptos build", "--lib-features", Some("hydrate"));
    test_option(&engine, "leptos serve", "--port", Some("3000"));
    test_option(&engine, "leptos serve", "--invalid-port", Some("abc"));
    println!();

    // Test suggestions
    println!("💡 Testing Suggestions:");
    test_suggestions(&engine, "build", "--relase");
    test_suggestions(&engine, "build", "--verbos");
    test_suggestions(&engine, "test", "--no-capture");
    println!();

    // Test strict validation
    println!("🔒 Testing Strict Validation:");
    let strict_config = ValidationConfig::with_level(ValidationLevel::Strict);
    let strict_engine = ValidationEngine::with_config(strict_config);

    test_option(&strict_engine, "build", "--release", None);
    test_option(&strict_engine, "build", "--unknown-option", None);
    println!();

    // Test validation levels
    println!("⚙️  Testing Validation Levels:");
    for level in [
        ValidationLevel::Off,
        ValidationLevel::Normal,
        ValidationLevel::Strict,
    ] {
        let config = ValidationConfig::with_level(level);
        let engine = ValidationEngine::with_config(config);

        let result = engine.validate_option("build", "--unknown-option", None);
        println!(
            "  {:?}: {}",
            level,
            if result.is_ok() {
                "✅ PASS"
            } else {
                "❌ FAIL"
            }
        );
    }
}

fn test_option(engine: &ValidationEngine, command: &str, option: &str, value: Option<&str>) {
    let result = engine.validate_option(command, option, value);
    let value_str = value.map_or(String::new(), |v| format!(" {v}"));

    match result {
        Ok(_) => println!("  ✅ {command} {option}{value_str}"),
        Err(e) => println!("  ❌ {command} {option}{value_str}: {e}"),
    }
}

fn test_suggestions(engine: &ValidationEngine, command: &str, misspelled: &str) {
    let suggestions = engine.suggest_option(command, misspelled);
    if suggestions.is_empty() {
        println!("  💭 {command} {misspelled}: No suggestions");
    } else {
        println!(
            "  💭 {} {}: Did you mean {}?",
            command,
            misspelled,
            suggestions.join(", ")
        );
    }
}