path: root/src/stream/verb.rs

/**
 * Code to represent an activitystreams verb.
 *
 * SPDX-FileCopyrightText: 2023 Eilertsens Kodeknekkeri
 * SPDX-FileCopyrightText: 2023 Harald Eilertsen <haraldei@anduin.net>
 *
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */

use serde::Deserialize;

#[derive(Debug, PartialEq)]
pub enum Verb {
    Post,
    Like,
    Update,
}

impl<'de> Deserialize<'de> for Verb {
    fn deserialize<D>(deserializer: D) -> Result<Verb, D::Error>
        where
            D: serde::de::Deserializer<'de>,
    {
        deserializer.deserialize_str(VerbVisitor)
    }
}

struct VerbVisitor;

impl<'de> serde::de::Visitor<'de> for VerbVisitor {
    type Value = Verb;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(formatter, "a valid activity streams verb URI")
    }

    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
    {
        match s {
            "http://activitystrea.ms/schema/1.0/post" =>
                Ok(Verb::Post),
            "http://activitystrea.ms/schema/1.0/like" =>
                Ok(Verb::Like),
            "http://activitystrea.ms/schema/1.0/update" =>
                Ok(Verb::Update),
            _ =>
                Err(E::custom(format!("unknown activity streams verb")))
        }
    }
}


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

    #[test]
    fn deserialize_activitustreams_verb_from_json() {
        #[derive(Debug, Deserialize, PartialEq)]
        struct VerbTest {
            verb: Verb
        }

        let verbs = vec![
            (Verb::Post, "post"),
            (Verb::Like, "like"),
            (Verb::Update, "update")
        ];

        for v in verbs {
            let verb: VerbTest = serde_json::from_str(
                &format!(r#"{{"verb": "http://activitystrea.ms/schema/1.0/{}"}}"#, v.1)
            ).unwrap();
            assert_eq!(v.0, verb.verb);
        }

    }
}