333 lines
10 KiB
Rust
333 lines
10 KiB
Rust
//! Types and Traits for dealing with Unparsed data
|
|
//!
|
|
//! Since ActivityStreams is extensible, and structured in a heirarchy of types, Data that was not
|
|
//! required to construct a given type might still come in handy when extending a into a subobject.
|
|
//!
|
|
//! For example, a `Create` activity is an extension of an `Object`, but if we need to store that
|
|
//! type on another object, we need to make the type system happy. Since any number of types both
|
|
//! provided and extended might need to be stored in the same key, a type called `AnyBase` exists.
|
|
//! AnyBase, when containing a `Base`, can be extended into a `Create` activity so long as the
|
|
//! required keys are present in it's `Unparsed` struct.
|
|
//!
|
|
//! For the most part, users of this library won't care about this module, but if you need to
|
|
//! create an Extension, it will come in handy.
|
|
//!
|
|
//! Let's implement a part of the Security extension to be compatible with Mastodon.
|
|
//!
|
|
//! ```rust
|
|
//! use activitystreams::{
|
|
//! actor::{AsApActor, ApActor},
|
|
//! base::{AsBase, Base, Extends},
|
|
//! markers,
|
|
//! object::{AsObject, Object},
|
|
//! prelude::*,
|
|
//! primitives::*,
|
|
//! unparsed::*,
|
|
//! iri_string::types::IriString,
|
|
//! };
|
|
//!
|
|
//! /// First, we'll define our public key types
|
|
//!
|
|
//! #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
|
|
//! #[serde(rename_all = "camelCase")]
|
|
//! pub struct PublicKeyValues {
|
|
//! pub id: IriString,
|
|
//! pub owner: IriString,
|
|
//! pub public_key_pem: String,
|
|
//! }
|
|
//!
|
|
//! #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
|
|
//! #[serde(rename_all = "camelCase")]
|
|
//! pub struct PublicKey<Inner> {
|
|
//! pub public_key: PublicKeyValues,
|
|
//! pub inner: Inner,
|
|
//! }
|
|
//!
|
|
//!
|
|
//! /// Then, we'll implement Extends so we can produce a PublicKey<Object> from an AnyBase.
|
|
//!
|
|
//! impl<Inner> Extends for PublicKey<Inner>
|
|
//! where
|
|
//! Inner: Extends<Error=serde_json::Error> + UnparsedMut,
|
|
//! {
|
|
//! type Kind = Inner::Kind;
|
|
//! type Error = serde_json::Error;
|
|
//!
|
|
//! fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
|
|
//! let mut inner = Inner::extends(base)?;
|
|
//!
|
|
//! Ok(PublicKey {
|
|
//! public_key: inner.unparsed_mut().remove("publicKey")?,
|
|
//! inner,
|
|
//! })
|
|
//! }
|
|
//!
|
|
//! fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
|
|
//! let PublicKey {
|
|
//! public_key,
|
|
//! mut inner,
|
|
//! } = self;
|
|
//!
|
|
//! inner.unparsed_mut().insert("publicKey", public_key)?;
|
|
//!
|
|
//! inner.retracts()
|
|
//! }
|
|
//! }
|
|
//!
|
|
//!
|
|
//! /// Auto-implement Base, Object, and Actor when Inner supports it
|
|
//! impl<Inner> markers::Base for PublicKey<Inner> where Inner: markers::Base {}
|
|
//! impl<Inner> markers::Object for PublicKey<Inner> where Inner: markers::Object {}
|
|
//! impl<Inner> markers::Actor for PublicKey<Inner> where Inner: markers::Actor {}
|
|
//!
|
|
//!
|
|
//! /// If we want to easily access getters and setters for internal types, we'll need to forward
|
|
//! /// those, too.
|
|
//!
|
|
//! /// Forward for base methods
|
|
//! ///
|
|
//! /// This allows us to access methods related to `context`, `id`, `kind`, `name`,
|
|
//! /// `media_type`, and `preview` directly from the PublicKey struct
|
|
//! impl<Inner> AsBase for PublicKey<Inner>
|
|
//! where
|
|
//! Inner: AsBase,
|
|
//! {
|
|
//! type Kind = Inner::Kind;
|
|
//!
|
|
//! fn base_ref(&self) -> &Base<Self::Kind> {
|
|
//! self.inner.base_ref()
|
|
//! }
|
|
//!
|
|
//! fn base_mut(&mut self) -> &mut Base<Self::Kind> {
|
|
//! self.inner.base_mut()
|
|
//! }
|
|
//! }
|
|
//!
|
|
//! /// Forward for object methods
|
|
//! ///
|
|
//! /// This allows us to access methods related to `url`, `generator`, `start_time`, `duration`,
|
|
//! /// and more directly from the PublicKey struct
|
|
//! impl<Inner> AsObject for PublicKey<Inner>
|
|
//! where
|
|
//! Inner: AsObject,
|
|
//! {
|
|
//! type Kind = Inner::Kind;
|
|
//!
|
|
//! fn object_ref(&self) -> &Object<Self::Kind> {
|
|
//! self.inner.object_ref()
|
|
//! }
|
|
//!
|
|
//! fn object_mut(&mut self) -> &mut Object<Self::Kind> {
|
|
//! self.inner.object_mut()
|
|
//! }
|
|
//! }
|
|
//!
|
|
//! /// Forward for ActivityPub actor methods
|
|
//! ///
|
|
//! /// This allows us to access methods related to `inbox`, `outbox`, `following`, `followers`,
|
|
//! /// `liked`, `streams`, `endpoints`, and more directly from the PublicKey struct
|
|
//! impl<Inner> AsApActor for PublicKey<Inner>
|
|
//! where
|
|
//! Inner: AsApActor,
|
|
//! {
|
|
//! type Inner = Inner::Inner;
|
|
//!
|
|
//! fn ap_actor_ref(&self) -> &ApActor<Self::Inner> {
|
|
//! self.inner.ap_actor_ref()
|
|
//! }
|
|
//!
|
|
//! fn ap_actor_mut(&mut self) -> &mut ApActor<Self::Inner> {
|
|
//! self.inner.ap_actor_mut()
|
|
//! }
|
|
//! }
|
|
//!
|
|
//!
|
|
//! /// If we want to be able to extend from our own type, we'll need to forward some
|
|
//! /// implementations, and create some traits
|
|
//!
|
|
//! /// Make it easy for downstreams to get an Unparsed
|
|
//! impl<Inner> UnparsedMut for PublicKey<Inner>
|
|
//! where
|
|
//! Inner: UnparsedMut,
|
|
//! {
|
|
//! fn unparsed_mut(&mut self) -> &mut Unparsed {
|
|
//! self.inner.unparsed_mut()
|
|
//! }
|
|
//! }
|
|
//!
|
|
//! /// Create our own extensible trait
|
|
//! pub trait AsPublicKey<Inner> {
|
|
//! fn public_key_ref(&self) -> &PublicKey<Inner>;
|
|
//! fn public_key_mut(&mut self) -> &mut PublicKey<Inner>;
|
|
//! }
|
|
//!
|
|
//! /// Implement it
|
|
//! impl<Inner> AsPublicKey<Inner> for PublicKey<Inner> {
|
|
//! fn public_key_ref(&self) -> &Self {
|
|
//! self
|
|
//! }
|
|
//!
|
|
//! fn public_key_mut(&mut self) -> &mut Self {
|
|
//! self
|
|
//! }
|
|
//! }
|
|
//!
|
|
//! /// And now create helper methods
|
|
//! pub trait PublicKeyExt<Inner>: AsPublicKey<Inner> {
|
|
//! /// Borrow the public key's ID
|
|
//! fn key_id<'a>(&'a self) -> &'a IriString
|
|
//! where
|
|
//! Inner: 'a,
|
|
//! {
|
|
//! &self.public_key_ref().public_key.id
|
|
//! }
|
|
//!
|
|
//! /// Set the public key's ID
|
|
//! fn set_key_id(&mut self, id: IriString) -> &mut Self {
|
|
//! self.public_key_mut().public_key.id = id;
|
|
//! self
|
|
//! }
|
|
//!
|
|
//! /// Borrow the public key's Owner
|
|
//! fn key_owner<'a>(&'a self) -> &'a IriString
|
|
//! where
|
|
//! Inner: 'a,
|
|
//! {
|
|
//! &self.public_key_ref().public_key.owner
|
|
//! }
|
|
//!
|
|
//! /// Set the public key's Owner
|
|
//! fn set_key_owner(&mut self, owner: IriString) -> &mut Self {
|
|
//! self.public_key_mut().public_key.owner = owner;
|
|
//! self
|
|
//! }
|
|
//!
|
|
//! /// Borrow the public key's PEM encoded value
|
|
//! fn key_pem<'a>(&'a self) -> &'a str
|
|
//! where
|
|
//! Inner: 'a,
|
|
//! {
|
|
//! &self.public_key_ref().public_key.public_key_pem
|
|
//! }
|
|
//!
|
|
//! /// Set the public key's PEM encoded value
|
|
//! ///
|
|
//! /// In a real application, this might take a different type, such as RSA's RSAPublicKey, or
|
|
//! /// OpenSSL's or Ring's version
|
|
//! fn set_key_pem<T>(&mut self, pem: T) -> &mut Self
|
|
//! where
|
|
//! T: Into<String>,
|
|
//! {
|
|
//! self.public_key_mut().public_key.public_key_pem = pem.into();
|
|
//! self
|
|
//! }
|
|
//! }
|
|
//!
|
|
//! /// Finally, we'll automatically implement PublicKeyExt for any type implementing AsPublicKey
|
|
//! impl<T, Inner> PublicKeyExt<Inner> for T where T: AsPublicKey<Inner> {}
|
|
//!
|
|
//!
|
|
//! /// Now that eveything is implemented, we can use it like so:
|
|
//! use activitystreams::{actor::{kind::PersonType, Person}, fragment, iri};
|
|
//!
|
|
//! pub type ExtendedPerson = PublicKey<ApActor<Person>>;
|
|
//!
|
|
//! impl ExtendedPerson {
|
|
//! pub fn new(inbox: IriString, mut owner: IriString) -> Result<Self, anyhow::Error> {
|
|
//! let id = owner.clone();
|
|
//! owner.set_fragment(Some(fragment!("main-key").as_ref()));
|
|
//! Ok(PublicKey {
|
|
//! public_key: PublicKeyValues {
|
|
//! id,
|
|
//! owner,
|
|
//! public_key_pem: String::new(),
|
|
//! },
|
|
//! inner: ApActor::new(inbox, Person::new()),
|
|
//! })
|
|
//! }
|
|
//! }
|
|
//!
|
|
//! fn main() -> Result<(), anyhow::Error> {
|
|
//! let mut extended_person = ExtendedPerson::new(
|
|
//! iri!("https://example.com/user/inbox"),
|
|
//! iri!("https://example.com/user"),
|
|
//! )?;
|
|
//!
|
|
//! extended_person
|
|
//! .set_kind(PersonType::Person)
|
|
//! .set_id("https://example.com/user".parse()?)
|
|
//! .set_name("Demo User")
|
|
//! .set_preferred_username("user")
|
|
//! .set_outbox("https://example.com/user/outbox".parse()?)
|
|
//! .set_key_pem(
|
|
//! "------ BEGIN PUBLIC KEY ------\nasdfasdfasdfasdfasdfasdf..."
|
|
//! )
|
|
//! .set_key_owner("https://example.com/user".parse()?)
|
|
//! .set_key_id("https://example.com/user#main-key".parse()?);
|
|
//!
|
|
//! let string = serde_json::to_string(&extended_person)?;
|
|
//! println!("{}", string);
|
|
//! Ok(())
|
|
//! }
|
|
//! ```
|
|
|
|
/// A trait granting mutable access to an Unparsed struct
|
|
///
|
|
/// This is required for easy manipulation of Unparsed from potentially deeply nested structures.
|
|
pub trait UnparsedMut {
|
|
/// Get a mutable reference to Unparsed
|
|
fn unparsed_mut(&mut self) -> &mut Unparsed;
|
|
}
|
|
|
|
/// A helper trait providing two methods, 'insert' and 'remove', that is auto-implemented for
|
|
/// UnparsedMut types.
|
|
///
|
|
/// These methods are provided for easily pulling values from and inserting values into the
|
|
/// Unparsed struct.
|
|
pub trait UnparsedMutExt: UnparsedMut {
|
|
/// Remove a value from the Unparsed struct, provided it matches the expected type
|
|
fn remove<T>(&mut self, key: &str) -> Result<T, serde_json::Error>
|
|
where
|
|
T: serde::de::DeserializeOwned,
|
|
{
|
|
serde_json::from_value(self.unparsed_mut().remove(key))
|
|
}
|
|
|
|
/// Insert a value into the Unparsed struct if the value isn't Null
|
|
fn insert<T>(&mut self, key: &str, value: T) -> Result<&mut Self, serde_json::Error>
|
|
where
|
|
T: serde::ser::Serialize,
|
|
{
|
|
let value = serde_json::to_value(value)?;
|
|
|
|
if !value.is_null() {
|
|
self.unparsed_mut().insert(key.to_owned(), value);
|
|
}
|
|
|
|
Ok(self)
|
|
}
|
|
}
|
|
|
|
/// The Unparsed struct itself,
|
|
#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
|
|
#[serde(transparent)]
|
|
pub struct Unparsed(std::collections::HashMap<String, serde_json::Value>);
|
|
|
|
impl Unparsed {
|
|
pub(crate) fn remove(&mut self, key: &str) -> serde_json::Value {
|
|
self.0.remove(key).unwrap_or(serde_json::Value::Null)
|
|
}
|
|
|
|
pub(crate) fn insert(&mut self, key: String, value: serde_json::Value) {
|
|
self.0.insert(key, value);
|
|
}
|
|
}
|
|
|
|
impl UnparsedMut for Unparsed {
|
|
fn unparsed_mut(&mut self) -> &mut Unparsed {
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<T> UnparsedMutExt for T where T: UnparsedMut {}
|