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

use super::readable::ReadableDate;
use serde::{self, Deserialize, Deserializer, Serialize, Serializer};

#[derive(Debug, Clone, PartialEq)]
pub enum Status {
    Draft,
    Public,
    Internal,
}

impl Default for Status {
    fn default() -> Self {
        Self::Draft
    }
}

impl Serialize for Status {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(match *self {
            Self::Draft => "Draft",
            Self::Public => "Public",
            Self::Internal => "Internal",
        })
    }
}

impl<'de> Deserialize<'de> for Status {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        match String::deserialize(deserializer)?.as_ref() {
            "Draft" => Ok(Self::Draft),
            "Public" => Ok(Self::Public),
            "Internal" => Ok(Self::Internal),
            s @ _ => Err(serde::de::Error::custom(format!(
                "key [status] value not supported value {}",
                s
            ))),
        }
    }
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Banner {
    #[serde(rename = "Outdate", default)]
    pub outdate: i64
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FrontMatter {
    #[serde(rename = "Title")]
    pub title: String,

    #[serde(rename = "Create Date")]
    pub create_date: ReadableDate,

    #[serde(rename = "Last Update", default)]
    pub last_update: Option<ReadableDate>,

    #[serde(rename = "Description", default)]
    pub description: Option<String>,

    #[serde(rename = "Tags")]
    pub tags: Option<Vec<String>>,

    #[serde(rename = "Status", default)]
    pub status: Status,

    #[serde(rename = "Banner", default)]
    pub banner: Banner,
}

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

    #[test]
    fn deserialize() {
        let fm: FrontMatter = serde_yaml::from_str(
            r"
Title: Foo

Create Date: Jan 12, 2001
Last Update: Feb 02, 2002
",
        )
        .unwrap();
        assert_eq!(
            fm,
            FrontMatter {
                title: "Foo".to_owned(),
                create_date: ReadableDate::new(2001, 1, 12),
                last_update: Some(ReadableDate::new(2002, 2, 02)),
                status: Status::Draft,
                ..Default::default()
            }
        )
    }
}