omena-query 0.3.0

Omena query boundary over CME producer query fragments
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

use omena_cascade::CascadeOriginV0;
use omena_query_checker_orchestrator::OmenaCheckerCascadeDeclarationInputV0;
use serde::Serialize;

use super::cascade_checker::collect_query_checker_cascade_declarations;

const HTML_STANDARD_USER_AGENT_SAMPLE_CSS: &str =
    include_str!("../../data/html-standard-user-agent-sample/stylesheet.css");

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OmenaQueryCascadeOriginStylesheetV0 {
    pub schema_version: &'static str,
    pub product: &'static str,
    pub source_name: String,
    pub origin: CascadeOriginV0,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_pin: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub license: Option<&'static str>,
    pub declarations: Vec<OmenaCheckerCascadeDeclarationInputV0>,
}

pub fn summarize_omena_query_cascade_origin_stylesheet_v0(
    source_name: impl Into<String>,
    source: &str,
    origin: CascadeOriginV0,
) -> OmenaQueryCascadeOriginStylesheetV0 {
    let declarations = collect_query_checker_cascade_declarations(source)
        .into_iter()
        .map(|mut declaration| {
            declaration.input.origin = origin;
            declaration.input
        })
        .collect();
    OmenaQueryCascadeOriginStylesheetV0 {
        schema_version: "0",
        product: "omena-query.cascade-origin-stylesheet",
        source_name: source_name.into(),
        origin,
        source_url: None,
        source_pin: None,
        license: None,
        declarations,
    }
}

pub fn summarize_html_standard_user_agent_sample_v0() -> OmenaQueryCascadeOriginStylesheetV0 {
    let mut summary = summarize_omena_query_cascade_origin_stylesheet_v0(
        "html-standard-rendering-sample",
        HTML_STANDARD_USER_AGENT_SAMPLE_CSS,
        CascadeOriginV0::UserAgent,
    );
    summary.source_url =
        Some("https://html.spec.whatwg.org/multipage/rendering.html#flow-content-3".to_string());
    summary.source_pin = Some("whatwg/html@9377fd656f519b60524b92f09bcc9e6d937b2017".to_string());
    summary.license = Some("BSD-3-Clause");
    summary
}

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

    #[test]
    fn projects_user_stylesheets_through_the_shared_cascade_input_contract() {
        let summary = summarize_omena_query_cascade_origin_stylesheet_v0(
            "workspace-user-styles",
            ".card { color: green !important; }",
            CascadeOriginV0::User,
        );

        assert_eq!(summary.declarations.len(), 1);
        assert_eq!(summary.declarations[0].origin, CascadeOriginV0::User);
        assert!(summary.declarations[0].important);
        let user_json = serde_json::to_value(&summary.declarations[0]).unwrap_or_default();
        assert_eq!(user_json.get("origin"), Some(&serde_json::json!("user")));

        let author = summarize_omena_query_cascade_origin_stylesheet_v0(
            "author-styles",
            ".card { color: green; }",
            CascadeOriginV0::Author,
        );
        let author_json = serde_json::to_value(&author.declarations[0]).unwrap_or_default();
        assert!(author_json.get("origin").is_none());
    }

    #[test]
    fn projects_the_licensed_html_sample_as_user_agent_input() {
        let summary = summarize_html_standard_user_agent_sample_v0();

        assert!(summary.declarations.len() >= 8);
        assert!(
            summary
                .declarations
                .iter()
                .all(|declaration| declaration.origin == CascadeOriginV0::UserAgent)
        );
        assert_eq!(summary.license, Some("BSD-3-Clause"));
        assert!(
            summary
                .source_pin
                .as_deref()
                .is_some_and(|pin| pin.starts_with("whatwg/html@"))
        );
    }
}