ezcal 0.3.4

Ergonomic iCalendar + vCard library for Rust
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

use std::fmt;

/// A parameter on a content line (e.g., `LANGUAGE=en` or `VALUE=DATE`).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Parameter {
    pub name: String,
    pub values: Vec<String>,
}

impl Parameter {
    pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
        Self {
            name: name.into(),
            values: vec![value.into()],
        }
    }

    pub fn with_values(name: impl Into<String>, values: Vec<String>) -> Self {
        Self {
            name: name.into(),
            values,
        }
    }
}

impl fmt::Display for Parameter {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.name)?;
        write!(f, "=")?;
        for (i, v) in self.values.iter().enumerate() {
            if i > 0 {
                write!(f, ",")?;
            }
            // Quote values that contain special characters
            if v.contains([',', ':', ';', '"']) || v.contains(char::is_whitespace) {
                write!(f, "\"{}\"", v)?;
            } else {
                write!(f, "{}", v)?;
            }
        }
        Ok(())
    }
}

/// A property in an iCalendar or vCard object (e.g., `SUMMARY:Team Standup`).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Property {
    pub name: String,
    pub params: Vec<Parameter>,
    pub value: String,
}

impl Property {
    pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
        Self {
            name: name.into(),
            params: Vec::new(),
            value: value.into(),
        }
    }

    pub fn with_param(mut self, param: Parameter) -> Self {
        self.params.push(param);
        self
    }

    pub fn with_params(mut self, params: Vec<Parameter>) -> Self {
        self.params = params;
        self
    }

    /// Get the first parameter with the given name.
    pub fn param(&self, name: &str) -> Option<&Parameter> {
        let name_upper = name.to_uppercase();
        self.params
            .iter()
            .find(|p| p.name.to_uppercase() == name_upper)
    }

    /// Get the first value of a parameter with the given name.
    pub fn param_value(&self, name: &str) -> Option<&str> {
        self.param(name)
            .and_then(|p| p.values.first())
            .map(|s| s.as_str())
    }
}

impl fmt::Display for Property {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.name)?;
        for param in &self.params {
            write!(f, ";{}", param)?;
        }
        write!(f, ":{}", self.value)?;
        Ok(())
    }
}

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

    #[test]
    fn property_display_simple() {
        let prop = Property::new("SUMMARY", "Team Standup");
        assert_eq!(prop.to_string(), "SUMMARY:Team Standup");
    }

    #[test]
    fn property_display_with_params() {
        let prop = Property::new("DTSTART", "20260315T090000")
            .with_param(Parameter::new("VALUE", "DATE-TIME"))
            .with_param(Parameter::new("TZID", "America/New_York"));
        assert_eq!(
            prop.to_string(),
            "DTSTART;VALUE=DATE-TIME;TZID=America/New_York:20260315T090000"
        );
    }

    #[test]
    fn parameter_quoted_value() {
        let param = Parameter::new("CN", "John Doe");
        assert_eq!(param.to_string(), "CN=\"John Doe\"");
    }

    #[test]
    fn parameter_multi_value() {
        let param = Parameter::with_values("TYPE", vec!["WORK".into(), "VOICE".into()]);
        assert_eq!(param.to_string(), "TYPE=WORK,VOICE");
    }
}