lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README | LICENSE

parsed.rs (4285B)

      1 #[cfg(not(feature = "std"))]
      2 use alloc::{string::String, vec::Vec};
      3 
      4 use radroots_events::RadrootsNostrEvent;
      5 
      6 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
      7 #[derive(Clone, Debug, PartialEq, Eq)]
      8 pub struct RadrootsParsedData<T> {
      9     pub id: String,
     10     pub author: String,
     11     pub published_at: u32,
     12     pub kind: u32,
     13     pub data: T,
     14 }
     15 
     16 impl<T> RadrootsParsedData<T> {
     17     #[inline]
     18     pub fn new(id: String, author: String, published_at: u32, kind: u32, data: T) -> Self {
     19         Self {
     20             id,
     21             author,
     22             published_at,
     23             kind,
     24             data,
     25         }
     26     }
     27 }
     28 
     29 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
     30 #[derive(Clone, Debug)]
     31 pub struct RadrootsParsedEvent<T> {
     32     pub event: RadrootsNostrEvent,
     33     pub data: RadrootsParsedData<T>,
     34 }
     35 
     36 impl<T> RadrootsParsedEvent<T> {
     37     #[inline]
     38     pub fn new(event: RadrootsNostrEvent, data: RadrootsParsedData<T>) -> Self {
     39         Self { event, data }
     40     }
     41 
     42     #[allow(clippy::too_many_arguments)]
     43     pub fn from_parts(
     44         id: String,
     45         author: String,
     46         published_at: u32,
     47         kind: u32,
     48         content: String,
     49         tags: Vec<Vec<String>>,
     50         sig: String,
     51         data: T,
     52     ) -> Self {
     53         Self {
     54             event: RadrootsNostrEvent {
     55                 id: id.clone(),
     56                 author: author.clone(),
     57                 created_at: published_at,
     58                 kind,
     59                 tags,
     60                 content,
     61                 sig,
     62             },
     63             data: RadrootsParsedData::new(id, author, published_at, kind, data),
     64         }
     65     }
     66 }
     67 
     68 #[cfg(test)]
     69 mod tests {
     70     use super::{RadrootsParsedData, RadrootsParsedEvent};
     71     use radroots_events::RadrootsNostrEvent;
     72 
     73     #[test]
     74     fn parsed_data_constructor_maps_fields() {
     75         let out = RadrootsParsedData::new(
     76             "id".to_string(),
     77             "author".to_string(),
     78             10,
     79             30402,
     80             "payload".to_string(),
     81         );
     82         assert_eq!(out.id, "id");
     83         assert_eq!(out.author, "author");
     84         assert_eq!(out.published_at, 10);
     85         assert_eq!(out.kind, 30402);
     86         assert_eq!(out.data, "payload");
     87     }
     88 
     89     #[test]
     90     fn parsed_event_constructor_maps_event_and_data() {
     91         let event = RadrootsNostrEvent {
     92             id: "id".to_string(),
     93             author: "author".to_string(),
     94             created_at: 22,
     95             kind: 1,
     96             tags: vec![vec!["k".to_string(), "v".to_string()]],
     97             content: "content".to_string(),
     98             sig: "sig".to_string(),
     99         };
    100         let data = RadrootsParsedData::new(
    101             "id".to_string(),
    102             "author".to_string(),
    103             22,
    104             1,
    105             "payload".to_string(),
    106         );
    107 
    108         let out = RadrootsParsedEvent::new(event.clone(), data.clone());
    109         assert_eq!(out.event.id, event.id);
    110         assert_eq!(out.event.author, event.author);
    111         assert_eq!(out.event.created_at, event.created_at);
    112         assert_eq!(out.event.kind, event.kind);
    113         assert_eq!(out.event.tags, event.tags);
    114         assert_eq!(out.event.content, event.content);
    115         assert_eq!(out.event.sig, event.sig);
    116         assert_eq!(out.data, data);
    117     }
    118 
    119     #[test]
    120     fn parsed_event_from_parts_builds_consistent_structs() {
    121         let out = RadrootsParsedEvent::from_parts(
    122             "id".to_string(),
    123             "author".to_string(),
    124             77,
    125             1111,
    126             "hello".to_string(),
    127             vec![vec!["e".to_string(), "root".to_string()]],
    128             "sig".to_string(),
    129             "payload".to_string(),
    130         );
    131         assert_eq!(out.event.id, "id");
    132         assert_eq!(out.event.author, "author");
    133         assert_eq!(out.event.created_at, 77);
    134         assert_eq!(out.event.kind, 1111);
    135         assert_eq!(out.event.content, "hello");
    136         assert_eq!(
    137             out.event.tags,
    138             vec![vec!["e".to_string(), "root".to_string()]]
    139         );
    140         assert_eq!(out.event.sig, "sig");
    141         assert_eq!(out.data.id, "id");
    142         assert_eq!(out.data.author, "author");
    143         assert_eq!(out.data.published_at, 77);
    144         assert_eq!(out.data.kind, 1111);
    145         assert_eq!(out.data.data, "payload");
    146     }
    147 }