omena-cascade 0.4.0

Cascade-formal substrate for Omena CSS
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

use omena_cascade::{
    CascadeDeclaration, CascadeKey, CascadeLevel, CascadeValue, LayerOrdinal, OpenWorldTieEvidence,
    Specificity, SpecificityExactnessV0, classify_cascade_ranked_set_loss, normalized_layer_rank,
};
use serde::Serialize;

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct FixtureResult {
    name: &'static str,
    classification: omena_cascade::CascadeRankedSetLossClassV0,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let lower = declaration(
        "lower",
        CascadeLevel::UserNormal,
        Specificity::new(9, 9, 9),
        SpecificityExactnessV0::Inexact,
    );
    let inexact_axis_winner = declaration(
        "inexact-axis-winner",
        CascadeLevel::AuthorNormal,
        Specificity::ZERO,
        SpecificityExactnessV0::Inexact,
    );
    let exact_axis_winner = declaration(
        "exact-axis-winner",
        CascadeLevel::AuthorNormal,
        Specificity::ZERO,
        SpecificityExactnessV0::Exact,
    );
    let specificity_only_winner = declaration(
        "specificity-only-winner",
        CascadeLevel::AuthorNormal,
        Specificity::new(0, 1, 0),
        SpecificityExactnessV0::Exact,
    );
    let specificity_only_runner_up = declaration(
        "specificity-only-runner-up",
        CascadeLevel::AuthorNormal,
        Specificity::ZERO,
        SpecificityExactnessV0::Inexact,
    );
    let single_inexact = declaration(
        "single-inexact",
        CascadeLevel::AuthorNormal,
        Specificity::ZERO,
        SpecificityExactnessV0::Inexact,
    );

    let results = [
        FixtureResult {
            name: "inexactAxisWinner",
            classification: classify_cascade_ranked_set_loss(&[lower.clone(), inexact_axis_winner]),
        },
        FixtureResult {
            name: "exactAxisWinner",
            classification: classify_cascade_ranked_set_loss(&[lower, exact_axis_winner]),
        },
        FixtureResult {
            name: "specificityOnlyWinner",
            classification: classify_cascade_ranked_set_loss(&[
                specificity_only_winner,
                specificity_only_runner_up,
            ]),
        },
        FixtureResult {
            name: "singleInexactCandidate",
            classification: classify_cascade_ranked_set_loss(&[single_inexact]),
        },
    ];
    println!("{}", serde_json::to_string(&results)?);
    Ok(())
}

fn declaration(
    id: &str,
    level: CascadeLevel,
    specificity: Specificity,
    exactness: SpecificityExactnessV0,
) -> CascadeDeclaration {
    CascadeDeclaration {
        id: id.to_string(),
        property: "color".to_string(),
        value: CascadeValue::Literal(id.to_string()),
        key: CascadeKey::new(
            level,
            normalized_layer_rank(false, LayerOrdinal::new(0)),
            0,
            specificity,
            0,
        ),
        open_world_tie_evidence: OpenWorldTieEvidence::NONE,
        specificity_exactness: exactness,
    }
}