cybercore 0.8.2

Shared config schema, palette, design tokens, and path conventions for the Cybercore Systems Framework
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

use cybercore::theme::{ThemeDocument, ThemePackDocument};
use std::{env, fs, process::ExitCode};

fn main() -> ExitCode {
    let args: Vec<String> = env::args().skip(1).collect();
    let Some(command) = args.first() else {
        usage();
        return ExitCode::from(2);
    };
    let strict = args.iter().any(|arg| arg == "--strict");
    let Some(path) = args.iter().skip(1).find(|arg| arg.as_str() != "--strict") else {
        usage();
        return ExitCode::from(2);
    };
    let input = match fs::read_to_string(path) {
        Ok(input) => input,
        Err(error) => {
            eprintln!("cannot read {path}: {error}");
            return ExitCode::FAILURE;
        }
    };

    match command.as_str() {
        "check" => check_theme(&input, path, strict),
        "validate-pack" => validate_pack(&input, path),
        _ => {
            usage();
            ExitCode::from(2)
        }
    }
}

fn check_theme(input: &str, path: &str, strict: bool) -> ExitCode {
    let id = std::path::Path::new(path)
        .file_stem()
        .and_then(|stem| stem.to_str())
        .unwrap_or("imported-theme");
    let document = match ThemeDocument::from_json(input, id) {
        Ok(document) => document,
        Err(error) => {
            eprintln!("theme validation failed: {error}");
            return ExitCode::FAILURE;
        }
    };
    let report = document.quality_report();
    let failures: Vec<_> = report.failures().collect();
    for check in &report.checks {
        println!(
            "{}: {} — {:.2}:1 (minimum {:.1}:1) {}",
            check.appearance.as_str(),
            check.check.label,
            check.check.ratio,
            check.check.minimum,
            if check.check.passes { "PASS" } else { "WARN" },
        );
    }
    if !report.has_explicit_light_variant {
        println!("light appearance: compatibility fallback in use");
    }
    if strict && (!failures.is_empty() || !report.has_explicit_light_variant) {
        eprintln!(
            "strict theme quality gate failed: {} contrast issue(s), explicit light variant: {}",
            failures.len(),
            report.has_explicit_light_variant
        );
        ExitCode::FAILURE
    } else {
        ExitCode::SUCCESS
    }
}

fn validate_pack(input: &str, path: &str) -> ExitCode {
    let pack: ThemePackDocument = match serde_json::from_str(input) {
        Ok(pack) => pack,
        Err(error) => {
            eprintln!("cannot parse pack {path}: {error}");
            return ExitCode::FAILURE;
        }
    };
    match pack.validate() {
        Ok(()) => {
            println!(
                "valid pack {} v{}: {} theme(s), license {}, Cybercore {}",
                pack.metadata.id,
                pack.metadata.version,
                pack.themes.len(),
                if pack.metadata.license.is_empty() {
                    "unspecified"
                } else {
                    &pack.metadata.license
                },
                pack.metadata.compatibility,
            );
            ExitCode::SUCCESS
        }
        Err(error) => {
            eprintln!("pack validation failed: {error}");
            ExitCode::FAILURE
        }
    }
}

fn usage() {
    eprintln!("Usage: cybercore-theme check <theme.json> [--strict]\n       cybercore-theme validate-pack <pack.cyberpack.json>");
}