fsvalidator 0.3.0

A file structure validator
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

#![deny(warnings)]

// You'll need the following feature enabled:
//
// `fsvalidator = { version = "0.2", features = ["toml"] }`
//
use anyhow::Result;

use fsvalidator::from_toml;
use fsvalidator::display::{format_validation_result, COLORS, SYMBOLS};

fn main() -> Result<()> {
    // Print a colorful header
    println!("{}{}Filesystem Validator Example{}", COLORS.bold, COLORS.blue, COLORS.reset);
    println!("{}═════════════════════════{}\n", COLORS.blue, COLORS.reset);

    // Load the validation structure from TOML
    let root = from_toml("examples/basic/fsvalidator.toml")?;
    println!("{}{}Structure Definition:{}\n{root}", COLORS.bold, COLORS.cyan, COLORS.reset);

    let path = "./examples/basic";
    
    // Validate with categorized errors
    let result = root.validate(path);
    
    println!("\n{}{}Validation Results:{}", COLORS.bold, COLORS.magenta, COLORS.reset);
    println!("{}", format_validation_result(&result, path));
    
    // For demonstration, show how to programmatically work with results
    match &result {
        Ok(_) => {
            println!("\n{}{}All checks passed!{}", COLORS.green, SYMBOLS.success, COLORS.reset);
        },
        Err(errors) => {
            // Count errors by category for a summary
            let mut missing_count = 0;
            let mut unexpected_count = 0;
            let mut name_mismatch_count = 0;
            let mut other_count = 0;
            
            // Helper function to count errors by category
            fn count_errors_by_category(error: &fsvalidator::ValidationError, 
                                       missing: &mut usize,
                                       unexpected: &mut usize,
                                       name_mismatch: &mut usize,
                                       other: &mut usize) {
                use fsvalidator::ErrorCategory;
                
                match error.category {
                    ErrorCategory::Missing => *missing += 1,
                    ErrorCategory::Unexpected => *unexpected += 1,
                    ErrorCategory::NameMismatch => *name_mismatch += 1,
                    _ => *other += 1,
                }
                
                for child in &error.children {
                    count_errors_by_category(child, missing, unexpected, name_mismatch, other);
                }
            }
            
            count_errors_by_category(errors, &mut missing_count, &mut unexpected_count, 
                                    &mut name_mismatch_count, &mut other_count);
            
            println!("\n{}{}Error Summary:{}", COLORS.bold, COLORS.red, COLORS.reset);
            println!("  {}{}Missing items:{} {}", COLORS.yellow, SYMBOLS.warning, COLORS.reset, missing_count);
            println!("  {}{}Unexpected items:{} {}", COLORS.cyan, SYMBOLS.warning, COLORS.reset, unexpected_count);
            println!("  {}{}Name mismatches:{} {}", COLORS.magenta, SYMBOLS.warning, COLORS.reset, name_mismatch_count);
            println!("  {}{}Other errors:{} {}", COLORS.red, SYMBOLS.warning, COLORS.reset, other_count);
        }
    }

    Ok(())
}