ics-core 0.0.0

Typed iCalendar (RFC 5545) model with vendor-extension support — shared core for makeholiday and future consumers. Placeholder version; first real release planned at v0.2.0.
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

//! Typed parser / formatter errors for `ics-core`.
//!
//! The `Parse` variant carries optional `line` and `property` fields.
//! `line` is the 1-based logical line number within the input document
//! (post-unfold). `property` is the offending property name when
//! identifiable.

use std::fmt;

#[derive(Debug, PartialEq, Eq)]
pub enum Error {
    Parse {
        message: String,
        line: Option<u32>,
        property: Option<String>,
    },
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Parse {
                message,
                line,
                property,
            } => {
                f.write_str("parse error")?;
                if let Some(l) = line {
                    write!(f, " at line {l}")?;
                }
                if let Some(p) = property {
                    write!(f, " [{p}]")?;
                }
                write!(f, ": {message}")
            }
        }
    }
}

impl std::error::Error for Error {}

impl Error {
    /// Construct a `Parse` error from a plain message with no line / property
    /// context. Use `parse_at_line` when a logical line number is available.
    pub fn parse(message: impl Into<String>) -> Self {
        Self::Parse {
            message: message.into(),
            line: None,
            property: None,
        }
    }

    /// Construct a `Parse` error attached to a specific 1-based logical
    /// line number.
    pub fn parse_at_line(line: u32, message: impl Into<String>) -> Self {
        Self::Parse {
            message: message.into(),
            line: Some(line),
            property: None,
        }
    }

    /// Like `parse_at_line` but also records the offending property name.
    pub fn parse_at(line: u32, property: impl Into<String>, message: impl Into<String>) -> Self {
        Self::Parse {
            message: message.into(),
            line: Some(line),
            property: Some(property.into()),
        }
    }
}

pub type Result<T> = std::result::Result<T, Error>;

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

    #[test]
    fn display_without_line_or_property() {
        let err = Error::parse("VEVENT missing DTSTAMP");
        assert_eq!(err.to_string(), "parse error: VEVENT missing DTSTAMP");
    }

    #[test]
    fn display_with_line_only() {
        let err = Error::parse_at_line(42, "VEVENT missing DTSTAMP");
        assert_eq!(
            err.to_string(),
            "parse error at line 42: VEVENT missing DTSTAMP"
        );
    }

    #[test]
    fn display_with_line_and_property() {
        let err = Error::parse_at(42, "DTSTAMP", "Invalid value");
        assert_eq!(
            err.to_string(),
            "parse error at line 42 [DTSTAMP]: Invalid value"
        );
    }
}