cdx-core 0.7.1

Core library for reading, writing, and validating Codex Document Format (.cdx) files
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

//! Continuous presentation layer.

use serde::{Deserialize, Serialize};

use super::style::{CssValue, Style, StyleMap};

/// Continuous presentation for screen reading.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Continuous {
    /// Format version.
    pub version: String,

    /// Presentation type (always "continuous").
    #[serde(rename = "type")]
    pub presentation_type: String,

    /// Default settings.
    pub defaults: ContinuousDefaults,

    /// Content sections.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub sections: Vec<Section>,

    /// Style definitions.
    #[serde(default, skip_serializing_if = "StyleMap::is_empty")]
    pub styles: StyleMap,
}

impl Default for Continuous {
    fn default() -> Self {
        Self {
            version: crate::SPEC_VERSION.to_string(),
            presentation_type: "continuous".to_string(),
            defaults: ContinuousDefaults::default(),
            sections: Vec::new(),
            styles: StyleMap::new(),
        }
    }
}

/// Default settings for continuous presentation.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ContinuousDefaults {
    /// Maximum content width.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_width: Option<CssValue>,

    /// Content padding.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub padding: Option<CssValue>,

    /// Default font family.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub font_family: Option<String>,

    /// Default font size.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub font_size: Option<CssValue>,

    /// Default line height.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub line_height: Option<CssValue>,
}

impl Default for ContinuousDefaults {
    fn default() -> Self {
        Self {
            max_width: Some(CssValue::String("800px".to_string())),
            padding: Some(CssValue::String("24px".to_string())),
            font_family: None,
            font_size: None,
            line_height: None,
        }
    }
}

/// A section of content in continuous presentation.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Section {
    /// Block references in this section.
    pub block_refs: Vec<String>,

    /// Style name to apply.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub style: Option<String>,

    /// Inline style attributes.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attributes: Option<Style>,
}

impl Section {
    /// Create a new section with block references.
    #[must_use]
    pub fn new(block_refs: Vec<String>) -> Self {
        Self {
            block_refs,
            style: None,
            attributes: None,
        }
    }

    /// Create a section with a named style.
    #[must_use]
    pub fn with_style(block_refs: Vec<String>, style: impl Into<String>) -> Self {
        Self {
            block_refs,
            style: Some(style.into()),
            attributes: None,
        }
    }
}

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

    #[test]
    fn test_continuous_default() {
        let c = Continuous::default();
        assert_eq!(c.presentation_type, "continuous");
        assert!(matches!(
            c.defaults.max_width,
            Some(CssValue::String(ref s)) if s == "800px"
        ));
    }

    #[test]
    fn test_section() {
        let section = Section::with_style(vec!["block-1".to_string()], "intro");
        assert_eq!(section.block_refs, vec!["block-1"]);
        assert_eq!(section.style, Some("intro".to_string()));
    }

    #[test]
    fn test_serialization() {
        let c = Continuous::default();
        let json = serde_json::to_string_pretty(&c).unwrap();
        assert!(json.contains("\"type\": \"continuous\""));
        assert!(json.contains("\"maxWidth\": \"800px\""));
    }

    #[test]
    fn test_deserialization() {
        let json = r#"{
            "version": "0.1",
            "type": "continuous",
            "defaults": {
                "maxWidth": "720px",
                "padding": "20px",
                "fontFamily": "Georgia, serif",
                "fontSize": "18px",
                "lineHeight": 1.7
            },
            "styles": {
                "heading1": {
                    "fontSize": "2.5rem",
                    "fontWeight": 700
                }
            }
        }"#;

        let c: Continuous = serde_json::from_str(json).unwrap();
        assert_eq!(c.defaults.font_family, Some("Georgia, serif".to_string()));
        assert!(c.styles.contains_key("heading1"));
    }
}