nyanoblog/src/ap/trans/actor.rs

use iref::IriBuf;
use rdf_types::vocabulary::IriIndex;
use rdf_types::Vocabulary;
use std::fmt;

use crate::ap::trans::{AbstractObject, ApDocument, DebugApub, ParseApub, PropHelper, RawObject};
use crate::ap::vocab::Ids;

pub struct AbstractActor {
    _super: AbstractObject,
    inbox: Option<IriBuf>,
    outbox: Option<IriBuf>,
    following: Option<IriBuf>,
    followers: Option<IriBuf>,
    liked: Option<IriBuf>,
    preferred_username: Option<String>,
    // Mastodon extensions
    featured: Option<Box<ApDocument>>,
    featured_tags: Option<Box<ApDocument>>,
    discoverable: Option<bool>,
    suspended: Option<bool>,
}
ap_extends!(AbstractActor, AbstractObject);

impl<V: Vocabulary<Iri = IriIndex>> ParseApub<V> for AbstractActor {
    fn parse_apub(obj: &RawObject, vocab: &V, ids: &Ids) -> Option<Self> {
        let ph = PropHelper::new(obj, vocab, ids)?;

        let result = unsafe { AbstractObject::_parse_apub_unchecked(obj, vocab, ids) };
        result.map(|s| Self {
            _super: s,
            inbox: ph.parse_prop(&ids.apub.property.inbox),
            outbox: ph.parse_prop(&ids.apub.property.outbox),
            following: ph.parse_prop(&ids.apub.property.following),
            followers: ph.parse_prop(&ids.apub.property.followers),
            liked: ph.parse_prop(&ids.apub.property.liked),
            preferred_username: ph.parse_prop(&ids.apub.property.preferred_username),
            featured: ph.parse_prop_box(&ids.toot.props.featured),
            featured_tags: ph.parse_prop_box(&ids.toot.props.featured_tags),
            discoverable: ph.parse_prop(&ids.toot.props.discoverable),
            suspended: ph.parse_prop(&ids.toot.props.suspended),
        })
    }
}

impl DebugApub for AbstractActor {
    fn apub_class_name(&self) -> &str {
        "Actor"
    }

    fn debug_apub_members(&self, f: &mut fmt::Formatter, depth: usize) -> fmt::Result {
        self._super.debug_apub_members(f, depth)?;
        ap_display_prop!(self, f, inbox, depth)?;
        ap_display_prop!(self, f, outbox, depth)?;
        ap_display_prop!(self, f, following, depth)?;
        ap_display_prop!(self, f, followers, depth)?;
        ap_display_prop!(self, f, liked, depth)?;
        ap_display_prop!(self, f, preferred_username, depth)?;
        ap_display_prop_box!(self, f, featured, depth)?;
        ap_display_prop_box!(self, f, featured_tags, depth)?;
        ap_display_prop!(self, f, discoverable, depth)?;
        ap_display_prop!(self, f, suspended, depth)
    }
}

pub enum Actor {
    Application(Application),
    Group(Group),
    Organization(Organization),
    Person(Person),
    Service(Service),
}

impl<V: Vocabulary<Iri = IriIndex>> ParseApub<V> for Actor {
    fn parse_apub(obj: &RawObject, vocab: &V, ids: &Ids) -> Option<Self> {
        Application::parse_apub(obj, vocab, ids)
            .map(Self::Application)
            .or_else(|| Group::parse_apub(obj, vocab, ids).map(Self::Group))
            .or_else(|| Organization::parse_apub(obj, vocab, ids).map(Self::Organization))
            .or_else(|| Person::parse_apub(obj, vocab, ids).map(Self::Person))
            .or_else(|| Service::parse_apub(obj, vocab, ids).map(Self::Service))
    }
}

impl DebugApub for Actor {
    fn apub_class_name(&self) -> &str {
        use Actor::*;
        match self {
            Application(a) => a.apub_class_name(),
            Group(g) => g.apub_class_name(),
            Organization(o) => o.apub_class_name(),
            Person(p) => p.apub_class_name(),
            Service(s) => s.apub_class_name(),
        }
    }

    fn debug_apub(&self, f: &mut fmt::Formatter, depth: usize) -> fmt::Result {
        use Actor::*;
        match self {
            Application(a) => a.debug_apub(f, depth),
            Group(g) => g.debug_apub(f, depth),
            Organization(o) => o.debug_apub(f, depth),
            Person(p) => p.debug_apub(f, depth),
            Service(s) => s.debug_apub(f, depth),
        }
    }

    fn debug_apub_members(&self, f: &mut fmt::Formatter, depth: usize) -> fmt::Result {
        use Actor::*;
        match self {
            Application(a) => a.debug_apub_members(f, depth),
            Group(g) => g.debug_apub_members(f, depth),
            Organization(o) => o.debug_apub_members(f, depth),
            Person(p) => p.debug_apub_members(f, depth),
            Service(s) => s.debug_apub_members(f, depth),
        }
    }
}

ap_empty_child_impl!(Application, AbstractActor, apub, object, application);
ap_empty_child_impl!(Group, AbstractActor, apub, object, group);
ap_empty_child_impl!(Organization, AbstractActor, apub, object, organization);
ap_empty_child_impl!(Person, AbstractActor, apub, object, person);
ap_empty_child_impl!(Service, AbstractActor, apub, object, service);