commit 1d6fd582612317db4a178185900a85933b8384bf parent 52abe09ac2fcce8910e5133c15b17cd28de32803 Author: triesap <tyson@radroots.org> Date: Sun, 15 Feb 2026 17:51:02 +0000 events-codec: apply cargo fmt Diffstat:
80 files changed, 597 insertions(+), 340 deletions(-)
diff --git a/events-codec/src/app_data/decode.rs b/events-codec/src/app_data/decode.rs @@ -1,9 +1,14 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, - app_data::{RadrootsAppData, RadrootsAppDataEventIndex, RadrootsAppDataEventMetadata, KIND_APP_DATA}, + app_data::{ + KIND_APP_DATA, RadrootsAppData, RadrootsAppDataEventIndex, RadrootsAppDataEventMetadata, + }, tags::TAG_D, }; diff --git a/events-codec/src/app_data/encode.rs b/events-codec/src/app_data/encode.rs @@ -1,7 +1,11 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec, + vec::Vec, +}; -use radroots_events::app_data::{RadrootsAppData, KIND_APP_DATA}; +use radroots_events::app_data::{KIND_APP_DATA, RadrootsAppData}; use radroots_events::tags::TAG_D; use crate::error::EventEncodeError; diff --git a/events-codec/src/comment/decode.rs b/events-codec/src/comment/decode.rs @@ -1,5 +1,8 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, diff --git a/events-codec/src/comment/encode.rs b/events-codec/src/comment/encode.rs @@ -1,10 +1,7 @@ #[cfg(not(feature = "std"))] use alloc::{string::String, vec::Vec}; -use radroots_events::{ - comment::RadrootsComment, - RadrootsNostrEventRef, -}; +use radroots_events::{RadrootsNostrEventRef, comment::RadrootsComment}; use crate::error::EventEncodeError; use crate::event_ref::push_nip10_ref_tags; @@ -41,7 +38,8 @@ pub fn comment_build_tags(comment: &RadrootsComment) -> Result<Vec<Vec<String>>, .d_tag .as_deref() .map_or(false, |v| !v.is_empty()); - let mut tags = Vec::with_capacity(6 + usize::from(root_has_addr) + usize::from(parent_has_addr)); + let mut tags = + Vec::with_capacity(6 + usize::from(root_has_addr) + usize::from(parent_has_addr)); push_nip10_ref_tags(&mut tags, &comment.root, "E", "P", "K", "A"); push_nip10_ref_tags(&mut tags, &comment.parent, "e", "p", "k", "a"); Ok(tags) diff --git a/events-codec/src/coop/decode.rs b/events-codec/src/coop/decode.rs @@ -2,7 +2,10 @@ #![forbid(unsafe_code)] #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, diff --git a/events-codec/src/coop/encode.rs b/events-codec/src/coop/encode.rs @@ -1,7 +1,10 @@ #![forbid(unsafe_code)] #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ coop::{RadrootsCoop, RadrootsCoopRef}, @@ -85,5 +88,9 @@ pub fn to_wire_parts_with_kind( } let tags = coop_build_tags(coop)?; let content = serde_json::to_string(coop).map_err(|_| EventEncodeError::Json)?; - Ok(WireEventParts { kind, content, tags }) + Ok(WireEventParts { + kind, + content, + tags, + }) } diff --git a/events-codec/src/coop/list_sets.rs b/events-codec/src/coop/list_sets.rs @@ -1,7 +1,12 @@ #![forbid(unsafe_code)] #[cfg(not(feature = "std"))] -use alloc::{format, string::{String, ToString}, vec, vec::Vec}; +use alloc::{ + format, + string::{String, ToString}, + vec, + vec::Vec, +}; use radroots_events::farm::RadrootsFarmRef; use radroots_events::kinds::KIND_FARM; @@ -162,9 +167,7 @@ where }) } -pub fn member_of_coops_list_set<I, S>( - coop_pubkeys: I, -) -> Result<RadrootsListSet, EventEncodeError> +pub fn member_of_coops_list_set<I, S>(coop_pubkeys: I) -> Result<RadrootsListSet, EventEncodeError> where I: IntoIterator<Item = S>, S: AsRef<str>, diff --git a/events-codec/src/coop/mod.rs b/events-codec/src/coop/mod.rs @@ -6,15 +6,15 @@ pub mod list_sets; #[cfg(test)] mod tests { - use radroots_events::coop::{RadrootsCoop, RadrootsCoopLocation, RadrootsCoopRef}; - use radroots_events::farm::{RadrootsFarmRef, RadrootsGcsLocation, RadrootsGeoJsonPoint, RadrootsGeoJsonPolygon}; use crate::coop::encode::{coop_build_tags, coop_ref_tags}; use crate::coop::list_sets::{ - coop_items_list_set, - coop_members_farms_list_set, - coop_members_list_set, + coop_items_list_set, coop_members_farms_list_set, coop_members_list_set, member_of_coops_list_set, }; + use radroots_events::coop::{RadrootsCoop, RadrootsCoopLocation, RadrootsCoopRef}; + use radroots_events::farm::{ + RadrootsFarmRef, RadrootsGcsLocation, RadrootsGeoJsonPoint, RadrootsGeoJsonPolygon, + }; #[test] fn coop_tags_include_required_fields() { @@ -80,15 +80,20 @@ mod tests { }; let tags = coop_ref_tags(&coop).expect("coop ref tags"); - let has_a = tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("a")); - let has_p = tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("p")); + let has_a = tags + .iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("a")); + let has_p = tags + .iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("p")); assert!(has_a); assert!(has_p); } #[test] fn coop_list_sets_include_expected_tags() { - let members = coop_members_list_set("BAAAAAAAAAAAAAAAAAAAAA", ["member_pubkey"]).expect("members list"); + let members = coop_members_list_set("BAAAAAAAAAAAAAAAAAAAAA", ["member_pubkey"]) + .expect("members list"); assert_eq!(members.d_tag, "coop:BAAAAAAAAAAAAAAAAAAAAA:members"); assert_eq!(members.entries.len(), 1); assert_eq!(members.entries[0].tag, "p"); @@ -101,12 +106,18 @@ mod tests { }], ) .expect("farm members list"); - assert_eq!(farm_members.d_tag, "coop:BAAAAAAAAAAAAAAAAAAAAA:members.farms"); + assert_eq!( + farm_members.d_tag, + "coop:BAAAAAAAAAAAAAAAAAAAAA:members.farms" + ); assert!(farm_members.entries.iter().any(|entry| entry.tag == "a")); assert!(farm_members.entries.iter().any(|entry| entry.tag == "p")); - let items = coop_items_list_set("BAAAAAAAAAAAAAAAAAAAAA", ["30361:coop_pubkey:FAAAAAAAAAAAAAAAAAAAAA"]) - .expect("items list"); + let items = coop_items_list_set( + "BAAAAAAAAAAAAAAAAAAAAA", + ["30361:coop_pubkey:FAAAAAAAAAAAAAAAAAAAAA"], + ) + .expect("items list"); assert_eq!(items.d_tag, "coop:BAAAAAAAAAAAAAAAAAAAAA:items"); assert_eq!(items.entries.len(), 1); assert_eq!(items.entries[0].tag, "a"); diff --git a/events-codec/src/document/decode.rs b/events-codec/src/document/decode.rs @@ -2,7 +2,10 @@ #![forbid(unsafe_code)] #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, diff --git a/events-codec/src/document/encode.rs b/events-codec/src/document/encode.rs @@ -1,13 +1,13 @@ #![forbid(unsafe_code)] #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; - -use radroots_events::{ - document::RadrootsDocument, - tags::TAG_D, +use alloc::{ + string::{String, ToString}, + vec::Vec, }; +use radroots_events::{document::RadrootsDocument, tags::TAG_D}; + use crate::d_tag::validate_d_tag; use crate::error::EventEncodeError; @@ -28,7 +28,9 @@ fn push_tag(tags: &mut Vec<Vec<String>>, key: &str, value: &str) { tags.push(tag); } -pub fn document_build_tags(document: &RadrootsDocument) -> Result<Vec<Vec<String>>, EventEncodeError> { +pub fn document_build_tags( + document: &RadrootsDocument, +) -> Result<Vec<Vec<String>>, EventEncodeError> { if document.d_tag.trim().is_empty() { return Err(EventEncodeError::EmptyRequiredField("d_tag")); } @@ -78,5 +80,9 @@ pub fn to_wire_parts_with_kind( } let tags = document_build_tags(document)?; let content = serde_json::to_string(document).map_err(|_| EventEncodeError::Json)?; - Ok(WireEventParts { kind, content, tags }) + Ok(WireEventParts { + kind, + content, + tags, + }) } diff --git a/events-codec/src/document/mod.rs b/events-codec/src/document/mod.rs @@ -5,8 +5,8 @@ pub mod encode; #[cfg(test)] mod tests { - use radroots_events::document::{RadrootsDocument, RadrootsDocumentSubject}; use crate::document::encode::document_build_tags; + use radroots_events::document::{RadrootsDocument, RadrootsDocumentSubject}; #[test] fn document_tags_include_required_fields() { diff --git a/events-codec/src/event_ref.rs b/events-codec/src/event_ref.rs @@ -1,5 +1,8 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::RadrootsNostrEventRef; diff --git a/events-codec/src/farm/decode.rs b/events-codec/src/farm/decode.rs @@ -1,7 +1,10 @@ #![cfg(feature = "serde_json")] #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, diff --git a/events-codec/src/farm/encode.rs b/events-codec/src/farm/encode.rs @@ -1,5 +1,8 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ farm::{RadrootsFarm, RadrootsFarmRef}, @@ -83,5 +86,9 @@ pub fn to_wire_parts_with_kind( } let tags = farm_build_tags(farm)?; let content = serde_json::to_string(farm).map_err(|_| EventEncodeError::Json)?; - Ok(WireEventParts { kind, content, tags }) + Ok(WireEventParts { + kind, + content, + tags, + }) } diff --git a/events-codec/src/farm/list_sets.rs b/events-codec/src/farm/list_sets.rs @@ -1,13 +1,18 @@ #![forbid(unsafe_code)] #[cfg(not(feature = "std"))] -use alloc::{format, string::{String, ToString}, vec, vec::Vec}; +use alloc::{ + format, + string::{String, ToString}, + vec, + vec::Vec, +}; +use radroots_events::kinds::KIND_LISTING; use radroots_events::list::RadrootsListEntry; use radroots_events::list_set::RadrootsListSet; -use radroots_events::plot::RadrootsPlot; use radroots_events::listing::RadrootsListing; -use radroots_events::kinds::KIND_LISTING; +use radroots_events::plot::RadrootsPlot; use crate::d_tag::validate_d_tag; use crate::error::EventEncodeError; @@ -195,9 +200,7 @@ where ) } -pub fn member_of_farms_list_set<I, S>( - farm_pubkeys: I, -) -> Result<RadrootsListSet, EventEncodeError> +pub fn member_of_farms_list_set<I, S>(farm_pubkeys: I) -> Result<RadrootsListSet, EventEncodeError> where I: IntoIterator<Item = S>, S: AsRef<str>, diff --git a/events-codec/src/farm/mod.rs b/events-codec/src/farm/mod.rs @@ -4,30 +4,24 @@ pub mod list_sets; #[cfg(test)] mod tests { - use radroots_events::farm::{ - RadrootsFarm, - RadrootsFarmLocation, - RadrootsFarmRef, - RadrootsGcsLocation, - RadrootsGeoJsonPoint, - RadrootsGeoJsonPolygon, - }; - use radroots_events::plot::RadrootsPlot; use crate::error::EventEncodeError; use crate::farm::encode::{farm_build_tags, farm_ref_tags}; use crate::farm::list_sets::{ - farm_members_list_set, - farm_listings_list_set_from_listings, - farm_plots_list_set_from_plots, - member_of_farms_list_set, + farm_listings_list_set_from_listings, farm_members_list_set, + farm_plots_list_set_from_plots, member_of_farms_list_set, }; use radroots_core::{ RadrootsCoreCurrency, RadrootsCoreDecimal, RadrootsCoreMoney, RadrootsCoreQuantity, RadrootsCoreQuantityPrice, RadrootsCoreUnit, }; + use radroots_events::farm::{ + RadrootsFarm, RadrootsFarmLocation, RadrootsFarmRef, RadrootsGcsLocation, + RadrootsGeoJsonPoint, RadrootsGeoJsonPolygon, + }; use radroots_events::listing::{ RadrootsListing, RadrootsListingBin, RadrootsListingFarmRef, RadrootsListingProduct, }; + use radroots_events::plot::RadrootsPlot; #[test] fn farm_tags_include_required_fields() { @@ -110,15 +104,20 @@ mod tests { }; let tags = farm_ref_tags(&farm).expect("farm ref tags"); - let has_a = tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("a")); - let has_p = tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("p")); + let has_a = tags + .iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("a")); + let has_p = tags + .iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("p")); assert!(has_a); assert!(has_p); } #[test] fn farm_list_sets_include_expected_tags() { - let members = farm_members_list_set("AAAAAAAAAAAAAAAAAAAAAA", ["owner_pubkey"]).expect("members list"); + let members = farm_members_list_set("AAAAAAAAAAAAAAAAAAAAAA", ["owner_pubkey"]) + .expect("members list"); assert_eq!(members.d_tag, "farm:AAAAAAAAAAAAAAAAAAAAAA:members"); assert_eq!(members.entries.len(), 1); assert_eq!(members.entries[0].tag, "p"); @@ -143,8 +142,9 @@ mod tests { tags: None, }]; - let plots_list = farm_plots_list_set_from_plots("AAAAAAAAAAAAAAAAAAAAAA", "farm_pubkey", &plots) - .expect("plots list"); + let plots_list = + farm_plots_list_set_from_plots("AAAAAAAAAAAAAAAAAAAAAA", "farm_pubkey", &plots) + .expect("plots list"); assert_eq!(plots_list.d_tag, "farm:AAAAAAAAAAAAAAAAAAAAAA:plots"); assert_eq!(plots_list.entries.len(), 1); assert_eq!(plots_list.entries[0].tag, "a"); @@ -206,8 +206,12 @@ mod tests { images: None, }]; - let listings_list = farm_listings_list_set_from_listings("AAAAAAAAAAAAAAAAAAAAAA", "farm_pubkey", &listings) - .expect("listings list"); + let listings_list = farm_listings_list_set_from_listings( + "AAAAAAAAAAAAAAAAAAAAAA", + "farm_pubkey", + &listings, + ) + .expect("listings list"); assert_eq!(listings_list.d_tag, "farm:AAAAAAAAAAAAAAAAAAAAAA:listings"); assert_eq!(listings_list.entries.len(), 1); assert_eq!(listings_list.entries[0].tag, "a"); diff --git a/events-codec/src/follow/decode.rs b/events-codec/src/follow/decode.rs @@ -3,7 +3,10 @@ use alloc::{string::String, vec::Vec}; use radroots_events::{ RadrootsNostrEvent, - follow::{RadrootsFollow, RadrootsFollowEventIndex, RadrootsFollowEventMetadata, RadrootsFollowProfile}, + follow::{ + RadrootsFollow, RadrootsFollowEventIndex, RadrootsFollowEventMetadata, + RadrootsFollowProfile, + }, kinds::KIND_FOLLOW, }; @@ -59,7 +62,10 @@ pub fn follow_from_tags( }); } let mut list = Vec::new(); - for tag in tags.iter().filter(|t| t.get(0).map(|s| s.as_str()) == Some("p")) { + for tag in tags + .iter() + .filter(|t| t.get(0).map(|s| s.as_str()) == Some("p")) + { list.push(parse_follow_tag(tag, published_at)?); } Ok(RadrootsFollow { list }) diff --git a/events-codec/src/follow/encode.rs b/events-codec/src/follow/encode.rs @@ -1,5 +1,8 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::follow::{RadrootsFollow, RadrootsFollowProfile}; @@ -15,7 +18,8 @@ fn follow_tag(profile: &RadrootsFollowProfile) -> Result<Vec<String>, EventEncod } let relay = profile.relay_url.as_ref().filter(|v| !v.is_empty()); let name = profile.contact_name.as_ref().filter(|v| !v.is_empty()); - let mut tag = Vec::with_capacity(2 + usize::from(relay.is_some()) + usize::from(name.is_some())); + let mut tag = + Vec::with_capacity(2 + usize::from(relay.is_some()) + usize::from(name.is_some())); tag.push("p".to_string()); tag.push(profile.public_key.clone()); if let Some(relay) = relay { diff --git a/events-codec/src/geochat/decode.rs b/events-codec/src/geochat/decode.rs @@ -1,5 +1,8 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, diff --git a/events-codec/src/geochat/encode.rs b/events-codec/src/geochat/encode.rs @@ -1,7 +1,10 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; -#[cfg(not(feature = "std"))] use alloc::vec; +#[cfg(not(feature = "std"))] +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::geochat::RadrootsGeoChat; use radroots_events::kinds::KIND_GEOCHAT; @@ -19,9 +22,7 @@ fn push_tag(tags: &mut Vec<Vec<String>>, key: &str, value: &str) { tags.push(vec![key.to_string(), value.to_string()]); } -pub fn geochat_build_tags( - geochat: &RadrootsGeoChat, -) -> Result<Vec<Vec<String>>, EventEncodeError> { +pub fn geochat_build_tags(geochat: &RadrootsGeoChat) -> Result<Vec<Vec<String>>, EventEncodeError> { let geohash = geochat.geohash.trim(); if geohash.is_empty() { return Err(EventEncodeError::EmptyRequiredField("geohash")); diff --git a/events-codec/src/gift_wrap/decode.rs b/events-codec/src/gift_wrap/decode.rs @@ -1,9 +1,15 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, - gift_wrap::{RadrootsGiftWrap, RadrootsGiftWrapEventIndex, RadrootsGiftWrapEventMetadata, RadrootsGiftWrapRecipient}, + gift_wrap::{ + RadrootsGiftWrap, RadrootsGiftWrapEventIndex, RadrootsGiftWrapEventMetadata, + RadrootsGiftWrapRecipient, + }, kinds::KIND_GIFT_WRAP, }; @@ -36,7 +42,9 @@ fn parse_expiration(tags: &[Vec<String>]) -> Result<Option<u32>, EventParseError .iter() .find(|t| t.get(0).map(|s| s.as_str()) == Some("expiration")) .and_then(|t| t.get(1)); - let Some(value) = value else { return Ok(None); }; + let Some(value) = value else { + return Ok(None); + }; if value.trim().is_empty() { return Err(EventParseError::InvalidTag("expiration")); } diff --git a/events-codec/src/gift_wrap/encode.rs b/events-codec/src/gift_wrap/encode.rs @@ -1,7 +1,10 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; -#[cfg(not(feature = "std"))] use alloc::vec; +#[cfg(not(feature = "std"))] +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::gift_wrap::{RadrootsGiftWrap, RadrootsGiftWrapRecipient}; use radroots_events::kinds::KIND_GIFT_WRAP; diff --git a/events-codec/src/job/encode.rs b/events-codec/src/job/encode.rs @@ -3,7 +3,7 @@ use core::fmt; #[cfg(not(feature = "std"))] use alloc::{string::String, vec, vec::Vec}; -pub use crate::wire::{canonicalize_tags, empty_content, to_draft, EventDraft, WireEventParts}; +pub use crate::wire::{EventDraft, WireEventParts, canonicalize_tags, empty_content, to_draft}; #[derive(Debug)] pub enum JobEncodeError { diff --git a/events-codec/src/job/feedback/decode.rs b/events-codec/src/job/feedback/decode.rs @@ -8,7 +8,10 @@ use radroots_events::{ }; #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use crate::job::{ error::JobParseError, diff --git a/events-codec/src/job/feedback/encode.rs b/events-codec/src/job/feedback/encode.rs @@ -4,12 +4,15 @@ use crate::job::encode::{JobEncodeError, WireEventParts, canonicalize_tags}; use crate::job::util::{feedback_status_tag, push_amount_tag_msat}; #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec, + vec::Vec, +}; pub fn job_feedback_build_tags(fb: &RadrootsJobFeedback) -> Vec<Vec<String>> { let mut tags: Vec<Vec<String>> = Vec::with_capacity( - 2 - + usize::from(fb.customer_pubkey.is_some()) + 2 + usize::from(fb.customer_pubkey.is_some()) + usize::from(fb.payment.is_some()) + usize::from(fb.encrypted), ); diff --git a/events-codec/src/job/mod.rs b/events-codec/src/job/mod.rs @@ -1,7 +1,7 @@ pub mod encode; pub mod error; -pub mod util; pub mod feedback; pub mod request; pub mod result; pub mod traits; +pub mod util; diff --git a/events-codec/src/job/request/encode.rs b/events-codec/src/job/request/encode.rs @@ -4,7 +4,11 @@ use crate::job::encode::{JobEncodeError, WireEventParts, canonicalize_tags}; use crate::job::util::{job_input_type_tag, push_bid_tag_sat}; #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec, + vec::Vec, +}; pub fn job_request_build_tags(req: &RadrootsJobRequest) -> Vec<Vec<String>> { let mut tags: Vec<Vec<String>> = Vec::with_capacity( diff --git a/events-codec/src/job/result/decode.rs b/events-codec/src/job/result/decode.rs @@ -7,7 +7,10 @@ use radroots_events::{ }; #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use crate::job::{ error::JobParseError, diff --git a/events-codec/src/job/result/encode.rs b/events-codec/src/job/result/encode.rs @@ -6,12 +6,15 @@ use crate::job::encode::{ use crate::job::util::{job_input_type_tag, push_amount_tag_msat}; #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec, + vec::Vec, +}; pub fn job_result_build_tags(res: &RadrootsJobResult) -> Vec<Vec<String>> { let mut tags: Vec<Vec<String>> = Vec::with_capacity( - 2 - + res.inputs.len() + 2 + res.inputs.len() + usize::from(res.customer_pubkey.is_some()) + usize::from(res.payment.is_some()) + usize::from(res.encrypted), diff --git a/events-codec/src/job/util.rs b/events-codec/src/job/util.rs @@ -1,5 +1,9 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec, + vec::Vec, +}; use radroots_events::{ job::{JobFeedbackStatus, JobInputType}, diff --git a/events-codec/src/lib.rs b/events-codec/src/lib.rs @@ -3,34 +3,34 @@ #[cfg(not(feature = "std"))] extern crate alloc; -pub mod error; pub mod d_tag; +pub mod error; pub mod event_ref; pub mod job; pub mod profile; pub mod tag_builders; pub mod wire; -pub mod comment; -pub mod follow; pub mod app_data; -pub mod document; +pub mod comment; pub mod coop; +pub mod document; pub mod farm; -pub mod resource_area; -pub mod resource_cap; -pub mod gift_wrap; +pub mod follow; pub mod geochat; +pub mod gift_wrap; pub mod message; pub mod message_file; -pub mod post; pub mod plot; +pub mod post; pub mod reaction; +pub mod resource_area; +pub mod resource_cap; pub mod seal; -pub mod listing; pub mod list; pub mod list_set; +pub mod listing; #[cfg(feature = "serde_json")] pub mod relay_document; diff --git a/events-codec/src/list/mod.rs b/events-codec/src/list/mod.rs @@ -25,8 +25,8 @@ mod tests { ], }; let tags = list_build_tags(&list).expect("build tags"); - let parsed = list_from_tags(KIND_LIST_MUTE, list.content.clone(), &tags) - .expect("parse list"); + let parsed = + list_from_tags(KIND_LIST_MUTE, list.content.clone(), &tags).expect("parse list"); assert_eq!(parsed.content, list.content); assert_eq!(parsed.entries.len(), list.entries.len()); assert_eq!(parsed.entries[0].tag, "p"); diff --git a/events-codec/src/list_set/decode.rs b/events-codec/src/list_set/decode.rs @@ -4,7 +4,7 @@ use alloc::{string::String, vec::Vec}; use radroots_events::{ RadrootsNostrEvent, kinds::is_nip51_list_set_kind, - list::{RadrootsListEntry}, + list::RadrootsListEntry, list_set::{RadrootsListSet, RadrootsListSetEventIndex, RadrootsListSetEventMetadata}, }; @@ -33,9 +33,7 @@ fn entry_from_tag(tag: &[String]) -> Result<RadrootsListEntry, EventParseError> } fn take_first_non_empty(tag: &[String]) -> Option<String> { - tag.get(1) - .filter(|v| !v.trim().is_empty()) - .cloned() + tag.get(1).filter(|v| !v.trim().is_empty()).cloned() } pub fn list_set_from_tags( diff --git a/events-codec/src/list_set/encode.rs b/events-codec/src/list_set/encode.rs @@ -1,11 +1,11 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; - -use radroots_events::{ - kinds::is_nip51_list_set_kind, - list_set::RadrootsListSet, +use alloc::{ + string::{String, ToString}, + vec::Vec, }; +use radroots_events::{kinds::is_nip51_list_set_kind, list_set::RadrootsListSet}; + use crate::error::EventEncodeError; #[cfg(feature = "serde_json")] use crate::list::encode::list_entries_to_tags; diff --git a/events-codec/src/list_set/mod.rs b/events-codec/src/list_set/mod.rs @@ -23,9 +23,7 @@ mod tests { use super::{decode::list_set_from_tags, encode::list_set_build_tags}; use crate::error::{EventEncodeError, EventParseError}; use radroots_events::{ - kinds::KIND_LIST_SET_FOLLOW, - list::{RadrootsListEntry}, - list_set::RadrootsListSet, + kinds::KIND_LIST_SET_FOLLOW, list::RadrootsListEntry, list_set::RadrootsListSet, }; #[test] diff --git a/events-codec/src/listing/decode.rs b/events-codec/src/listing/decode.rs @@ -1,13 +1,19 @@ #![cfg(feature = "serde_json")] #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, - kinds::{KIND_FARM, KIND_PLOT, KIND_RESOURCE_AREA}, kinds::KIND_LISTING, - listing::{RadrootsListing, RadrootsListingEventIndex, RadrootsListingEventMetadata, RadrootsListingFarmRef}, + kinds::{KIND_FARM, KIND_PLOT, KIND_RESOURCE_AREA}, + listing::{ + RadrootsListing, RadrootsListingEventIndex, RadrootsListingEventMetadata, + RadrootsListingFarmRef, + }, plot::RadrootsPlotRef, resource_area::RadrootsResourceAreaRef, tags::TAG_D, @@ -39,7 +45,10 @@ fn parse_d_tag(tags: &[Vec<String>]) -> Result<String, EventParseError> { } fn parse_farm_ref(tags: &[Vec<String>]) -> Result<RadrootsListingFarmRef, EventParseError> { - for tag in tags.iter().filter(|t| t.get(0).map(|s| s.as_str()) == Some(TAG_A)) { + for tag in tags + .iter() + .filter(|t| t.get(0).map(|s| s.as_str()) == Some(TAG_A)) + { let value = tag .get(1) .map(|s| s.to_string()) @@ -84,7 +93,9 @@ fn parse_farm_pubkey(tags: &[Vec<String>]) -> Result<String, EventParseError> { Ok(value) } -fn parse_resource_area(tags: &[Vec<String>]) -> Result<Option<RadrootsResourceAreaRef>, EventParseError> { +fn parse_resource_area( + tags: &[Vec<String>], +) -> Result<Option<RadrootsResourceAreaRef>, EventParseError> { let tag = tags .iter() .find(|t| t.get(0).map(|s| s.as_str()) == Some(TAG_RADROOTS_RESOURCE_AREA)); diff --git a/events-codec/src/listing/encode.rs b/events-codec/src/listing/encode.rs @@ -1,11 +1,11 @@ #[cfg(not(feature = "std"))] -use alloc::vec::Vec; -#[cfg(not(feature = "std"))] use alloc::string::String; +#[cfg(not(feature = "std"))] +use alloc::vec::Vec; -use radroots_events::listing::RadrootsListing; #[cfg(feature = "serde_json")] use radroots_events::kinds::KIND_LISTING; +use radroots_events::listing::RadrootsListing; use crate::error::EventEncodeError; use crate::listing::tags::listing_tags; @@ -31,5 +31,9 @@ pub fn to_wire_parts_with_kind( ) -> Result<WireEventParts, EventEncodeError> { let tags = listing_build_tags(listing)?; let content = serde_json::to_string(listing).map_err(|_| EventEncodeError::Json)?; - Ok(WireEventParts { kind, content, tags }) + Ok(WireEventParts { + kind, + content, + tags, + }) } diff --git a/events-codec/src/listing/tags.rs b/events-codec/src/listing/tags.rs @@ -1,19 +1,24 @@ #![forbid(unsafe_code)] #[cfg(not(feature = "std"))] -use alloc::{format, string::{String, ToString}, vec, vec::Vec}; +use alloc::{ + format, + string::{String, ToString}, + vec, + vec::Vec, +}; use core::cmp; use radroots_core::{RadrootsCoreDiscount, RadrootsCoreMoney}; +use radroots_events::kinds::{KIND_FARM, KIND_PLOT, KIND_RESOURCE_AREA}; use radroots_events::listing::{ - RadrootsListing, RadrootsListingAvailability, RadrootsListingDeliveryMethod, RadrootsListingFarmRef, - RadrootsListingBin, RadrootsListingImage, RadrootsListingLocation, - RadrootsListingStatus, + RadrootsListing, RadrootsListingAvailability, RadrootsListingBin, + RadrootsListingDeliveryMethod, RadrootsListingFarmRef, RadrootsListingImage, + RadrootsListingLocation, RadrootsListingStatus, }; use radroots_events::plot::RadrootsPlotRef; use radroots_events::resource_area::RadrootsResourceAreaRef; -use radroots_events::kinds::{KIND_FARM, KIND_PLOT, KIND_RESOURCE_AREA}; use radroots_events::tags::TAG_D; use crate::d_tag::validate_d_tag; @@ -140,10 +145,16 @@ pub fn listing_tags_with_options( push_tag_value(&mut tags, "year", year); } - tags.push(vec![TAG_RADROOTS_PRIMARY_BIN.to_string(), listing.primary_bin_id.clone()]); + tags.push(vec![ + TAG_RADROOTS_PRIMARY_BIN.to_string(), + listing.primary_bin_id.clone(), + ]); let mut bins: Vec<&RadrootsListingBin> = listing.bins.iter().collect(); - if let Some(pos) = bins.iter().position(|bin| bin.bin_id == listing.primary_bin_id) { + if let Some(pos) = bins + .iter() + .position(|bin| bin.bin_id == listing.primary_bin_id) + { let primary = bins.remove(pos); bins.insert(0, primary); } @@ -172,7 +183,10 @@ pub fn listing_tags_with_options( if let Some(availability) = &listing.availability { match availability { RadrootsListingAvailability::Status { status } => { - tags.push(vec![TAG_STATUS.to_string(), status_as_str(status).to_string()]); + tags.push(vec![ + TAG_STATUS.to_string(), + status_as_str(status).to_string(), + ]); } RadrootsListingAvailability::Window { start, end } => { if let Some(start) = start { @@ -336,7 +350,9 @@ fn tag_listing_price(bin: &RadrootsListingBin) -> Result<Vec<String>, EventEncod } let price = &bin.price_per_canonical_unit; if !price.is_price_per_canonical_unit() { - return Err(EventEncodeError::EmptyRequiredField("bin.price_per_canonical_unit")); + return Err(EventEncodeError::EmptyRequiredField( + "bin.price_per_canonical_unit", + )); } let mut tag = Vec::with_capacity(8); tag.push(TAG_RADROOTS_PRICE.to_string()); @@ -356,7 +372,9 @@ fn tag_listing_price(bin: &RadrootsListingBin) -> Result<Vec<String>, EventEncod (None, None) => {} (None, Some(_)) => return Err(EventEncodeError::EmptyRequiredField("bin.display_price")), (Some(_), None) => { - return Err(EventEncodeError::EmptyRequiredField("bin.display_price_unit")); + return Err(EventEncodeError::EmptyRequiredField( + "bin.display_price_unit", + )); } } Ok(tag) @@ -458,11 +476,7 @@ fn calculate_resolution(value: f64, max: u32) -> u32 { return 1; } let s = value.to_string(); - let decimals = s - .split('.') - .nth(1) - .map(|v| v.len() as u32) - .unwrap_or(0); + let decimals = s.split('.').nth(1).map(|v| v.len() as u32).unwrap_or(0); let bounded = cmp::min(decimals, max); if bounded == 0 { 1 } else { bounded } } diff --git a/events-codec/src/message/decode.rs b/events-codec/src/message/decode.rs @@ -1,12 +1,13 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, - message::{ - RadrootsMessage, RadrootsMessageEventIndex, RadrootsMessageEventMetadata, - }, kinds::KIND_MESSAGE, + message::{RadrootsMessage, RadrootsMessageEventIndex, RadrootsMessageEventMetadata}, }; use crate::error::EventParseError; diff --git a/events-codec/src/message/encode.rs b/events-codec/src/message/encode.rs @@ -1,8 +1,8 @@ #[cfg(not(feature = "std"))] use alloc::{string::String, vec::Vec}; -use radroots_events::message::RadrootsMessage; use radroots_events::kinds::KIND_MESSAGE; +use radroots_events::message::RadrootsMessage; use crate::error::EventEncodeError; use crate::message::tags::{build_recipient_tags, build_reply_tag, build_subject_tag}; diff --git a/events-codec/src/message/tags.rs b/events-codec/src/message/tags.rs @@ -1,7 +1,10 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; -#[cfg(not(feature = "std"))] use alloc::vec; +#[cfg(not(feature = "std"))] +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{RadrootsNostrEventPtr, message::RadrootsMessageRecipient}; @@ -9,7 +12,9 @@ use crate::error::{EventEncodeError, EventParseError}; fn validate_recipient(recipient: &RadrootsMessageRecipient) -> Result<(), EventEncodeError> { if recipient.public_key.trim().is_empty() { - return Err(EventEncodeError::EmptyRequiredField("recipients.public_key")); + return Err(EventEncodeError::EmptyRequiredField( + "recipients.public_key", + )); } if let Some(relay_url) = &recipient.relay_url { if relay_url.trim().is_empty() { @@ -98,7 +103,10 @@ pub(crate) fn parse_recipients( tags: &[Vec<String>], ) -> Result<Vec<RadrootsMessageRecipient>, EventParseError> { let mut recipients = Vec::new(); - for tag in tags.iter().filter(|t| t.get(0).map(|s| s.as_str()) == Some("p")) { + for tag in tags + .iter() + .filter(|t| t.get(0).map(|s| s.as_str()) == Some("p")) + { recipients.push(parse_recipient_tag(tag)?); } if recipients.is_empty() { @@ -135,9 +143,7 @@ pub(crate) fn parse_reply_tag( })) } -pub(crate) fn parse_subject_tag( - tags: &[Vec<String>], -) -> Result<Option<String>, EventParseError> { +pub(crate) fn parse_subject_tag(tags: &[Vec<String>]) -> Result<Option<String>, EventParseError> { let tag = match tags .iter() .find(|t| t.get(0).map(|s| s.as_str()) == Some("subject")) diff --git a/events-codec/src/message_file/decode.rs b/events-codec/src/message_file/decode.rs @@ -1,5 +1,8 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, @@ -27,7 +30,10 @@ fn required_tag_value(tags: &[Vec<String>], key: &'static str) -> Result<String, Ok(value.clone()) } -fn optional_tag_value(tags: &[Vec<String>], key: &'static str) -> Result<Option<String>, EventParseError> { +fn optional_tag_value( + tags: &[Vec<String>], + key: &'static str, +) -> Result<Option<String>, EventParseError> { let value = tags .iter() .find(|t| t.get(0).map(|s| s.as_str()) == Some(key)) @@ -40,9 +46,15 @@ fn optional_tag_value(tags: &[Vec<String>], key: &'static str) -> Result<Option< } fn parse_dimensions(value: &str) -> Result<RadrootsMessageFileDimensions, EventParseError> { - let (w, h) = value.split_once('x').ok_or(EventParseError::InvalidTag("dim"))?; - let w = w.parse::<u32>().map_err(|_| EventParseError::InvalidTag("dim"))?; - let h = h.parse::<u32>().map_err(|_| EventParseError::InvalidTag("dim"))?; + let (w, h) = value + .split_once('x') + .ok_or(EventParseError::InvalidTag("dim"))?; + let w = w + .parse::<u32>() + .map_err(|_| EventParseError::InvalidTag("dim"))?; + let h = h + .parse::<u32>() + .map_err(|_| EventParseError::InvalidTag("dim"))?; Ok(RadrootsMessageFileDimensions { w, h }) } @@ -51,7 +63,9 @@ fn parse_size(tags: &[Vec<String>]) -> Result<Option<u64>, EventParseError> { .iter() .find(|t| t.get(0).map(|s| s.as_str()) == Some("size")) .and_then(|t| t.get(1)); - let Some(value) = value else { return Ok(None); }; + let Some(value) = value else { + return Ok(None); + }; if value.trim().is_empty() { return Err(EventParseError::InvalidTag("size")); } @@ -61,12 +75,16 @@ fn parse_size(tags: &[Vec<String>]) -> Result<Option<u64>, EventParseError> { Ok(Some(size)) } -fn parse_dimensions_tag(tags: &[Vec<String>]) -> Result<Option<RadrootsMessageFileDimensions>, EventParseError> { +fn parse_dimensions_tag( + tags: &[Vec<String>], +) -> Result<Option<RadrootsMessageFileDimensions>, EventParseError> { let value = tags .iter() .find(|t| t.get(0).map(|s| s.as_str()) == Some("dim")) .and_then(|t| t.get(1)); - let Some(value) = value else { return Ok(None); }; + let Some(value) = value else { + return Ok(None); + }; if value.trim().is_empty() { return Err(EventParseError::InvalidTag("dim")); } @@ -75,7 +93,10 @@ fn parse_dimensions_tag(tags: &[Vec<String>]) -> Result<Option<RadrootsMessageFi fn parse_fallbacks(tags: &[Vec<String>]) -> Result<Vec<String>, EventParseError> { let mut fallbacks = Vec::new(); - for tag in tags.iter().filter(|t| t.get(0).map(|s| s.as_str()) == Some("fallback")) { + for tag in tags + .iter() + .filter(|t| t.get(0).map(|s| s.as_str()) == Some("fallback")) + { let value = tag.get(1).ok_or(EventParseError::InvalidTag("fallback"))?; if value.trim().is_empty() { return Err(EventParseError::InvalidTag("fallback")); diff --git a/events-codec/src/message_file/encode.rs b/events-codec/src/message_file/encode.rs @@ -1,7 +1,11 @@ #[cfg(not(feature = "std"))] -use alloc::{format, string::{String, ToString}, vec::Vec}; -#[cfg(not(feature = "std"))] use alloc::vec; +#[cfg(not(feature = "std"))] +use alloc::{ + format, + string::{String, ToString}, + vec::Vec, +}; use radroots_events::kinds::KIND_MESSAGE_FILE; use radroots_events::message_file::{RadrootsMessageFile, RadrootsMessageFileDimensions}; @@ -59,12 +63,7 @@ pub fn message_file_build_tags( tags.push(tag); } - push_required_tag( - &mut tags, - "file-type", - &message.file_type, - "file_type", - )?; + push_required_tag(&mut tags, "file-type", &message.file_type, "file_type")?; push_required_tag( &mut tags, "encryption-algorithm", diff --git a/events-codec/src/plot/decode.rs b/events-codec/src/plot/decode.rs @@ -1,12 +1,15 @@ #![cfg(feature = "serde_json")] #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, - kinds::{KIND_FARM, KIND_PLOT}, farm::RadrootsFarmRef, + kinds::{KIND_FARM, KIND_PLOT}, plot::{RadrootsPlot, RadrootsPlotEventIndex, RadrootsPlotEventMetadata}, tags::TAG_D, }; diff --git a/events-codec/src/plot/encode.rs b/events-codec/src/plot/encode.rs @@ -1,5 +1,8 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ farm::RadrootsFarmRef, @@ -104,5 +107,9 @@ pub fn to_wire_parts_with_kind( } let tags = plot_build_tags(plot)?; let content = serde_json::to_string(plot).map_err(|_| EventEncodeError::Json)?; - Ok(WireEventParts { kind, content, tags }) + Ok(WireEventParts { + kind, + content, + tags, + }) } diff --git a/events-codec/src/plot/mod.rs b/events-codec/src/plot/mod.rs @@ -3,11 +3,13 @@ pub mod encode; #[cfg(test)] mod tests { + use crate::plot::encode::plot_build_tags; use radroots_events::{ - farm::{RadrootsFarmRef, RadrootsGcsLocation, RadrootsGeoJsonPoint, RadrootsGeoJsonPolygon}, + farm::{ + RadrootsFarmRef, RadrootsGcsLocation, RadrootsGeoJsonPoint, RadrootsGeoJsonPolygon, + }, plot::{RadrootsPlot, RadrootsPlotLocation}, }; - use crate::plot::encode::plot_build_tags; #[test] fn plot_tags_include_farm_address() { @@ -61,8 +63,12 @@ mod tests { }; let tags = plot_build_tags(&plot).expect("tags"); - let has_a = tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("a")); - let has_p = tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("p")); + let has_a = tags + .iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("a")); + let has_p = tags + .iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("p")); assert!(has_a); assert!(has_p); } diff --git a/events-codec/src/post/decode.rs b/events-codec/src/post/decode.rs @@ -1,10 +1,13 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, - post::{RadrootsPost, RadrootsPostEventIndex, RadrootsPostEventMetadata}, kinds::KIND_POST, + post::{RadrootsPost, RadrootsPostEventIndex, RadrootsPostEventMetadata}, }; use crate::error::EventParseError; diff --git a/events-codec/src/profile/decode.rs b/events-codec/src/profile/decode.rs @@ -1,19 +1,18 @@ #![cfg(feature = "serde_json")] #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, + kinds::KIND_PROFILE, profile::{ - RadrootsProfileType, - RadrootsProfile, - RadrootsProfileEventIndex, - RadrootsProfileEventMetadata, - RADROOTS_PROFILE_TYPE_TAG_KEY, - radroots_profile_type_from_tag_value, + RADROOTS_PROFILE_TYPE_TAG_KEY, RadrootsProfile, RadrootsProfileEventIndex, + RadrootsProfileEventMetadata, RadrootsProfileType, radroots_profile_type_from_tag_value, }, - kinds::KIND_PROFILE, }; use crate::error::EventParseError; @@ -22,7 +21,10 @@ use serde_json::Value; const PROFILE_KIND: u32 = KIND_PROFILE; fn parse_optional_string(value: &Value, key: &'static str) -> Option<String> { - value.get(key).and_then(|v| v.as_str()).map(|s| s.to_string()) + value + .get(key) + .and_then(|v| v.as_str()) + .map(|s| s.to_string()) } fn parse_bot(value: &Value) -> Option<String> { diff --git a/events-codec/src/profile/encode.rs b/events-codec/src/profile/encode.rs @@ -1,12 +1,10 @@ use crate::profile::error::ProfileEncodeError; +#[cfg(feature = "serde_json")] +use radroots_events::kinds::KIND_PROFILE; use radroots_events::profile::{ - RadrootsProfileType, - RadrootsProfile, - RADROOTS_PROFILE_TYPE_TAG_KEY, + RADROOTS_PROFILE_TYPE_TAG_KEY, RadrootsProfile, RadrootsProfileType, radroots_profile_type_tag_value, }; -#[cfg(feature = "serde_json")] -use radroots_events::kinds::KIND_PROFILE; use nostr::Metadata; use nostr::prelude::Url; diff --git a/events-codec/src/reaction/decode.rs b/events-codec/src/reaction/decode.rs @@ -1,10 +1,13 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, - reaction::{RadrootsReaction, RadrootsReactionEventIndex, RadrootsReactionEventMetadata}, kinds::KIND_REACTION, + reaction::{RadrootsReaction, RadrootsReactionEventIndex, RadrootsReactionEventMetadata}, tags::TAG_E_ROOT, }; diff --git a/events-codec/src/reaction/encode.rs b/events-codec/src/reaction/encode.rs @@ -1,10 +1,7 @@ #[cfg(not(feature = "std"))] use alloc::{string::String, vec::Vec}; -use radroots_events::{ - reaction::RadrootsReaction, - RadrootsNostrEventRef, -}; +use radroots_events::{RadrootsNostrEventRef, reaction::RadrootsReaction}; use crate::error::EventEncodeError; use crate::event_ref::push_nip10_ref_tags; diff --git a/events-codec/src/resource_area/decode.rs b/events-codec/src/resource_area/decode.rs @@ -1,12 +1,17 @@ #![cfg(feature = "serde_json")] #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, kinds::KIND_RESOURCE_AREA, - resource_area::{RadrootsResourceArea, RadrootsResourceAreaEventIndex, RadrootsResourceAreaEventMetadata}, + resource_area::{ + RadrootsResourceArea, RadrootsResourceAreaEventIndex, RadrootsResourceAreaEventMetadata, + }, tags::TAG_D, }; diff --git a/events-codec/src/resource_area/encode.rs b/events-codec/src/resource_area/encode.rs @@ -1,5 +1,8 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ kinds::KIND_RESOURCE_AREA, @@ -92,5 +95,9 @@ pub fn to_wire_parts_with_kind( } let tags = resource_area_build_tags(area)?; let content = serde_json::to_string(area).map_err(|_| EventEncodeError::Json)?; - Ok(WireEventParts { kind, content, tags }) + Ok(WireEventParts { + kind, + content, + tags, + }) } diff --git a/events-codec/src/resource_area/list_sets.rs b/events-codec/src/resource_area/list_sets.rs @@ -1,7 +1,12 @@ #![forbid(unsafe_code)] #[cfg(not(feature = "std"))] -use alloc::{format, string::{String, ToString}, vec, vec::Vec}; +use alloc::{ + format, + string::{String, ToString}, + vec, + vec::Vec, +}; use radroots_events::farm::RadrootsFarmRef; use radroots_events::kinds::{KIND_FARM, KIND_PLOT}; diff --git a/events-codec/src/resource_area/mod.rs b/events-codec/src/resource_area/mod.rs @@ -1,21 +1,24 @@ #![forbid(unsafe_code)] -pub mod encode; pub mod decode; +pub mod encode; pub mod list_sets; #[cfg(test)] mod tests { - use radroots_events::farm::{RadrootsGcsLocation, RadrootsGeoJsonPoint, RadrootsGeoJsonPolygon}; - use radroots_events::resource_area::{RadrootsResourceArea, RadrootsResourceAreaLocation, RadrootsResourceAreaRef}; use crate::resource_area::encode::{resource_area_build_tags, resource_area_ref_tags}; use crate::resource_area::list_sets::{ - resource_area_members_farms_list_set, - resource_area_members_plots_list_set, + resource_area_members_farms_list_set, resource_area_members_plots_list_set, resource_area_stewards_list_set, }; use radroots_events::farm::RadrootsFarmRef; + use radroots_events::farm::{ + RadrootsGcsLocation, RadrootsGeoJsonPoint, RadrootsGeoJsonPolygon, + }; use radroots_events::plot::RadrootsPlotRef; + use radroots_events::resource_area::{ + RadrootsResourceArea, RadrootsResourceAreaLocation, RadrootsResourceAreaRef, + }; fn sample_location() -> RadrootsResourceAreaLocation { RadrootsResourceAreaLocation { @@ -69,9 +72,18 @@ mod tests { }; let tags = resource_area_build_tags(&area).expect("tags"); - assert!(tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("d"))); - assert!(tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("g"))); - assert!(tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("t"))); + assert!( + tags.iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("d")) + ); + assert!( + tags.iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("g")) + ); + assert!( + tags.iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("t")) + ); } #[test] @@ -82,8 +94,14 @@ mod tests { }; let tags = resource_area_ref_tags(&area_ref).expect("ref tags"); - assert!(tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("p"))); - assert!(tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("a"))); + assert!( + tags.iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("p")) + ); + assert!( + tags.iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("a")) + ); } #[test] @@ -112,9 +130,13 @@ mod tests { assert!(plots.entries.iter().any(|entry| entry.tag == "a")); assert!(plots.entries.iter().any(|entry| entry.tag == "p")); - let stewards = resource_area_stewards_list_set("AAAAAAAAAAAAAAAAAAAAAw", ["steward_pubkey"]) - .expect("stewards"); - assert_eq!(stewards.d_tag, "resource:AAAAAAAAAAAAAAAAAAAAAw:members.stewards"); + let stewards = + resource_area_stewards_list_set("AAAAAAAAAAAAAAAAAAAAAw", ["steward_pubkey"]) + .expect("stewards"); + assert_eq!( + stewards.d_tag, + "resource:AAAAAAAAAAAAAAAAAAAAAw:members.stewards" + ); assert!(stewards.entries.iter().any(|entry| entry.tag == "p")); } } diff --git a/events-codec/src/resource_cap/decode.rs b/events-codec/src/resource_cap/decode.rs @@ -1,12 +1,18 @@ #![cfg(feature = "serde_json")] #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, kinds::KIND_RESOURCE_HARVEST_CAP, - resource_cap::{RadrootsResourceHarvestCap, RadrootsResourceHarvestCapEventIndex, RadrootsResourceHarvestCapEventMetadata}, + resource_cap::{ + RadrootsResourceHarvestCap, RadrootsResourceHarvestCapEventIndex, + RadrootsResourceHarvestCapEventMetadata, + }, tags::TAG_D, }; diff --git a/events-codec/src/resource_cap/encode.rs b/events-codec/src/resource_cap/encode.rs @@ -1,10 +1,11 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ - kinds::KIND_RESOURCE_AREA, - resource_cap::RadrootsResourceHarvestCap, - tags::TAG_D, + kinds::KIND_RESOURCE_AREA, resource_cap::RadrootsResourceHarvestCap, tags::TAG_D, }; use crate::d_tag::validate_d_tag; @@ -80,9 +81,7 @@ pub fn resource_harvest_cap_build_tags( } #[cfg(feature = "serde_json")] -pub fn to_wire_parts( - cap: &RadrootsResourceHarvestCap, -) -> Result<WireEventParts, EventEncodeError> { +pub fn to_wire_parts(cap: &RadrootsResourceHarvestCap) -> Result<WireEventParts, EventEncodeError> { to_wire_parts_with_kind(cap, KIND_RESOURCE_HARVEST_CAP) } @@ -96,5 +95,9 @@ pub fn to_wire_parts_with_kind( } let tags = resource_harvest_cap_build_tags(cap)?; let content = serde_json::to_string(cap).map_err(|_| EventEncodeError::Json)?; - Ok(WireEventParts { kind, content, tags }) + Ok(WireEventParts { + kind, + content, + tags, + }) } diff --git a/events-codec/src/resource_cap/mod.rs b/events-codec/src/resource_cap/mod.rs @@ -1,14 +1,16 @@ #![forbid(unsafe_code)] -pub mod encode; pub mod decode; +pub mod encode; #[cfg(test)] mod tests { + use crate::resource_cap::encode::resource_harvest_cap_build_tags; use radroots_core::{RadrootsCoreDecimal, RadrootsCoreQuantity, RadrootsCoreUnit}; use radroots_events::resource_area::RadrootsResourceAreaRef; - use radroots_events::resource_cap::{RadrootsResourceHarvestCap, RadrootsResourceHarvestProduct}; - use crate::resource_cap::encode::resource_harvest_cap_build_tags; + use radroots_events::resource_cap::{ + RadrootsResourceHarvestCap, RadrootsResourceHarvestProduct, + }; #[test] fn resource_harvest_cap_tags_include_required_fields() { @@ -35,10 +37,25 @@ mod tests { }; let tags = resource_harvest_cap_build_tags(&cap).expect("tags"); - assert!(tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("d"))); - assert!(tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("a"))); - assert!(tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("key"))); - assert!(tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("start"))); - assert!(tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) == Some("end"))); + assert!( + tags.iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("d")) + ); + assert!( + tags.iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("a")) + ); + assert!( + tags.iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("key")) + ); + assert!( + tags.iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("start")) + ); + assert!( + tags.iter() + .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("end")) + ); } } diff --git a/events-codec/src/seal/decode.rs b/events-codec/src/seal/decode.rs @@ -1,5 +1,8 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; use radroots_events::{ RadrootsNostrEvent, diff --git a/events-codec/src/tag_builders.rs b/events-codec/src/tag_builders.rs @@ -6,53 +6,38 @@ use alloc::{string::String, vec::Vec}; use core::convert::Infallible; use radroots_events::{ - app_data::RadrootsAppData, - comment::RadrootsComment, - document::RadrootsDocument, - coop::RadrootsCoop, - follow::RadrootsFollow, - farm::RadrootsFarm, - geochat::RadrootsGeoChat, - resource_area::RadrootsResourceArea, - resource_cap::RadrootsResourceHarvestCap, - gift_wrap::RadrootsGiftWrap, - job_feedback::RadrootsJobFeedback, - job_request::RadrootsJobRequest, - job_result::RadrootsJobResult, - listing::RadrootsListing, - list::RadrootsList, - list_set::RadrootsListSet, - message::RadrootsMessage, - message_file::RadrootsMessageFile, - plot::RadrootsPlot, - post::RadrootsPost, - profile::RadrootsProfile, - reaction::RadrootsReaction, - seal::RadrootsSeal, + app_data::RadrootsAppData, comment::RadrootsComment, coop::RadrootsCoop, + document::RadrootsDocument, farm::RadrootsFarm, follow::RadrootsFollow, + geochat::RadrootsGeoChat, gift_wrap::RadrootsGiftWrap, job_feedback::RadrootsJobFeedback, + job_request::RadrootsJobRequest, job_result::RadrootsJobResult, list::RadrootsList, + list_set::RadrootsListSet, listing::RadrootsListing, message::RadrootsMessage, + message_file::RadrootsMessageFile, plot::RadrootsPlot, post::RadrootsPost, + profile::RadrootsProfile, reaction::RadrootsReaction, resource_area::RadrootsResourceArea, + resource_cap::RadrootsResourceHarvestCap, seal::RadrootsSeal, }; -use crate::comment::encode::comment_build_tags; -use crate::error::EventEncodeError; use crate::app_data::encode::app_data_build_tags; -use crate::document::encode::document_build_tags; +use crate::comment::encode::comment_build_tags; use crate::coop::encode::coop_build_tags; -use crate::follow::encode::follow_build_tags; +use crate::document::encode::document_build_tags; +use crate::error::EventEncodeError; use crate::farm::encode::farm_build_tags; +use crate::follow::encode::follow_build_tags; use crate::geochat::encode::geochat_build_tags; -use crate::resource_area::encode::resource_area_build_tags; -use crate::resource_cap::encode::resource_harvest_cap_build_tags; +use crate::gift_wrap::encode::gift_wrap_build_tags; use crate::job::encode::JobEncodeError; use crate::job::feedback::encode::job_feedback_build_tags; use crate::job::request::encode::job_request_build_tags; use crate::job::result::encode::job_result_build_tags; -use crate::listing::tags::listing_tags; use crate::list::encode::list_build_tags; use crate::list_set::encode::list_set_build_tags; +use crate::listing::tags::listing_tags; use crate::message::encode::message_build_tags; use crate::message_file::encode::message_file_build_tags; use crate::plot::encode::plot_build_tags; use crate::reaction::encode::reaction_build_tags; -use crate::gift_wrap::encode::gift_wrap_build_tags; +use crate::resource_area::encode::resource_area_build_tags; +use crate::resource_cap::encode::resource_harvest_cap_build_tags; use crate::seal::encode::seal_build_tags; pub trait RadrootsEventTagBuilder { diff --git a/events-codec/src/wire.rs b/events-codec/src/wire.rs @@ -1,5 +1,8 @@ #[cfg(not(feature = "std"))] -use alloc::{string::{String, ToString}, vec::Vec}; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; #[derive(Debug, Clone)] pub struct WireEventParts { diff --git a/events-codec/tests/app_data.rs b/events-codec/tests/app_data.rs @@ -1,5 +1,5 @@ use radroots_events::{ - app_data::{RadrootsAppData, KIND_APP_DATA}, + app_data::{KIND_APP_DATA, RadrootsAppData}, kinds::KIND_POST, }; use radroots_events_codec::app_data::decode::app_data_from_tags; diff --git a/events-codec/tests/comment.rs b/events-codec/tests/comment.rs @@ -1,10 +1,10 @@ mod common; +use radroots_events::tags::{TAG_E_PREV, TAG_E_ROOT}; use radroots_events::{ comment::RadrootsComment, kinds::{KIND_COMMENT, KIND_POST}, }; -use radroots_events::tags::{TAG_E_PREV, TAG_E_ROOT}; use radroots_events_codec::comment::decode::comment_from_tags; use radroots_events_codec::comment::encode::{comment_build_tags, to_wire_parts}; diff --git a/events-codec/tests/event_ref.rs b/events-codec/tests/event_ref.rs @@ -2,7 +2,9 @@ mod common; use radroots_events::kinds::KIND_POST; use radroots_events_codec::error::EventParseError; -use radroots_events_codec::event_ref::{build_event_ref_tag, find_event_ref_tag, parse_event_ref_tag}; +use radroots_events_codec::event_ref::{ + build_event_ref_tag, find_event_ref_tag, parse_event_ref_tag, +}; #[test] fn build_and_parse_roundtrip_with_d_tag_and_relays() { diff --git a/events-codec/tests/follow.rs b/events-codec/tests/follow.rs @@ -5,7 +5,7 @@ use radroots_events::{ use radroots_events_codec::error::{EventEncodeError, EventParseError}; use radroots_events_codec::follow::decode::follow_from_tags; -use radroots_events_codec::follow::encode::{follow_apply, FollowMutation, to_wire_parts}; +use radroots_events_codec::follow::encode::{FollowMutation, follow_apply, to_wire_parts}; #[test] fn follow_to_wire_parts_builds_p_tags() { @@ -133,7 +133,10 @@ fn follow_apply_adds_and_updates_entries() { assert_eq!(updated.list.len(), 2); assert_eq!(updated.list[0].public_key, "pubkey-a"); assert_eq!(updated.list[0].relay_url.as_deref(), Some("wss://relay")); - assert_eq!(updated.list[0].contact_name.as_deref(), Some("alice-updated")); + assert_eq!( + updated.list[0].contact_name.as_deref(), + Some("alice-updated") + ); let added = follow_apply( &follow, diff --git a/events-codec/tests/job_feedback.rs b/events-codec/tests/job_feedback.rs @@ -2,7 +2,7 @@ mod common; use radroots_events::job::{JobFeedbackStatus, JobPaymentRequest}; use radroots_events::job_feedback::RadrootsJobFeedback; -use radroots_events::kinds::{KIND_JOB_FEEDBACK, KIND_JOB_RESULT_MIN, KIND_JOB_REQUEST_MIN}; +use radroots_events::kinds::{KIND_JOB_FEEDBACK, KIND_JOB_REQUEST_MIN, KIND_JOB_RESULT_MIN}; use radroots_events_codec::job::encode::JobEncodeError; use radroots_events_codec::job::error::JobParseError; use radroots_events_codec::job::feedback::decode::job_feedback_from_tags; diff --git a/events-codec/tests/job_request.rs b/events-codec/tests/job_request.rs @@ -1,6 +1,6 @@ use radroots_events::job::JobInputType; -use radroots_events::kinds::{KIND_JOB_FEEDBACK, KIND_JOB_REQUEST_MIN, KIND_JOB_RESULT_MIN}; use radroots_events::job_request::{RadrootsJobInput, RadrootsJobParam, RadrootsJobRequest}; +use radroots_events::kinds::{KIND_JOB_FEEDBACK, KIND_JOB_REQUEST_MIN, KIND_JOB_RESULT_MIN}; use radroots_events_codec::job::encode::JobEncodeError; use radroots_events_codec::job::error::JobParseError; use radroots_events_codec::job::request::decode::job_request_from_tags; diff --git a/events-codec/tests/job_result.rs b/events-codec/tests/job_result.rs @@ -1,9 +1,9 @@ mod common; use radroots_events::job::{JobInputType, JobPaymentRequest}; -use radroots_events::kinds::{KIND_JOB_REQUEST_MIN, KIND_JOB_RESULT_MIN}; use radroots_events::job_request::RadrootsJobInput; use radroots_events::job_result::RadrootsJobResult; +use radroots_events::kinds::{KIND_JOB_REQUEST_MIN, KIND_JOB_RESULT_MIN}; use radroots_events_codec::job::encode::JobEncodeError; use radroots_events_codec::job::error::JobParseError; use radroots_events_codec::job::result::decode::job_result_from_tags; diff --git a/events-codec/tests/job_traits.rs b/events-codec/tests/job_traits.rs @@ -1,7 +1,7 @@ +use radroots_events::RadrootsNostrEvent; use radroots_events::job::JobInputType; use radroots_events::job_request::{RadrootsJobInput, RadrootsJobParam, RadrootsJobRequest}; use radroots_events::kinds::KIND_JOB_REQUEST_MIN; -use radroots_events::RadrootsNostrEvent; use radroots_events_codec::job::request::encode::to_wire_parts; use radroots_events_codec::job::traits::{BorrowedEventAdapter, JobEventLike}; diff --git a/events-codec/tests/job_util.rs b/events-codec/tests/job_util.rs @@ -23,7 +23,10 @@ fn input_type_tag_roundtrip() { #[test] fn feedback_status_tag_roundtrip() { let t = feedback_status_tag(JobFeedbackStatus::Processing); - assert_eq!(feedback_status_from_tag(t), Some(JobFeedbackStatus::Processing)); + assert_eq!( + feedback_status_from_tag(t), + Some(JobFeedbackStatus::Processing) + ); assert_eq!(feedback_status_from_tag("unknown"), None); } @@ -105,7 +108,11 @@ fn push_amount_tag_msat_writes_msat() { push_amount_tag_msat(&mut tags, 12, Some("bolt".to_string())); assert_eq!( tags[0], - vec!["amount".to_string(), "12000".to_string(), "bolt".to_string()] + vec![ + "amount".to_string(), + "12000".to_string(), + "bolt".to_string() + ] ); } diff --git a/events-codec/tests/listing.rs b/events-codec/tests/listing.rs @@ -1,20 +1,20 @@ #![cfg(feature = "serde_json")] use radroots_core::{ - RadrootsCoreCurrency, RadrootsCoreDecimal, RadrootsCoreDiscount, - RadrootsCoreDiscountScope, RadrootsCoreDiscountThreshold, RadrootsCoreDiscountValue, - RadrootsCoreMoney, RadrootsCoreQuantity, RadrootsCoreQuantityPrice, RadrootsCoreUnit, + RadrootsCoreCurrency, RadrootsCoreDecimal, RadrootsCoreDiscount, RadrootsCoreDiscountScope, + RadrootsCoreDiscountThreshold, RadrootsCoreDiscountValue, RadrootsCoreMoney, + RadrootsCoreQuantity, RadrootsCoreQuantityPrice, RadrootsCoreUnit, }; +use radroots_events::tags::TAG_D; use radroots_events::{ kinds::{KIND_LISTING, KIND_POST}, listing::{ - RadrootsListing, RadrootsListingAvailability, RadrootsListingDeliveryMethod, - RadrootsListingBin, RadrootsListingFarmRef, RadrootsListingImage, + RadrootsListing, RadrootsListingAvailability, RadrootsListingBin, + RadrootsListingDeliveryMethod, RadrootsListingFarmRef, RadrootsListingImage, RadrootsListingImageSize, RadrootsListingLocation, RadrootsListingProduct, RadrootsListingStatus, }, }; -use radroots_events::tags::TAG_D; use radroots_events_codec::error::{EventEncodeError, EventParseError}; use radroots_events_codec::listing::decode::listing_from_event; use radroots_events_codec::listing::encode::{listing_build_tags, to_wire_parts}; @@ -22,7 +22,8 @@ use radroots_events_codec::listing::tags::listing_tags_full; use std::str::FromStr; fn sample_listing(d_tag: &str) -> RadrootsListing { - let quantity = RadrootsCoreQuantity::new(RadrootsCoreDecimal::from(1u32), RadrootsCoreUnit::Each); + let quantity = + RadrootsCoreQuantity::new(RadrootsCoreDecimal::from(1u32), RadrootsCoreUnit::Each); let price = RadrootsCoreQuantityPrice::new( RadrootsCoreMoney::new(RadrootsCoreDecimal::from(10u32), RadrootsCoreCurrency::USD), quantity.clone(), @@ -143,10 +144,7 @@ fn sample_listing_full(d_tag: &str) -> RadrootsListing { fn listing_build_tags_requires_d_tag() { let listing = sample_listing(""); let err = listing_build_tags(&listing).unwrap_err(); - assert!(matches!( - err, - EventEncodeError::EmptyRequiredField("d") - )); + assert!(matches!(err, EventEncodeError::EmptyRequiredField("d"))); } #[test] @@ -176,7 +174,10 @@ fn listing_from_event_fills_missing_d_tag() { let tags = vec![ vec![TAG_D.to_string(), "FAAAAAAAAAAAAAAAAAAAAA".to_string()], vec!["p".to_string(), "farm_pubkey".to_string()], - vec!["a".to_string(), "30340:farm_pubkey:AAAAAAAAAAAAAAAAAAAAAA".to_string()], + vec![ + "a".to_string(), + "30340:farm_pubkey:AAAAAAAAAAAAAAAAAAAAAA".to_string(), + ], ]; let decoded = listing_from_event(KIND_LISTING, &tags, &content).unwrap(); @@ -190,7 +191,10 @@ fn listing_from_event_rejects_mismatched_d_tag() { let tags = vec![ vec![TAG_D.to_string(), "AAAAAAAAAAAAAAAAAAAAAQ".to_string()], vec!["p".to_string(), "farm_pubkey".to_string()], - vec!["a".to_string(), "30340:farm_pubkey:AAAAAAAAAAAAAAAAAAAAAA".to_string()], + vec![ + "a".to_string(), + "30340:farm_pubkey:AAAAAAAAAAAAAAAAAAAAAA".to_string(), + ], ]; let err = listing_from_event(KIND_LISTING, &tags, &content).unwrap_err(); @@ -204,7 +208,10 @@ fn listing_from_event_rejects_wrong_kind() { let tags = vec![ vec![TAG_D.to_string(), "AAAAAAAAAAAAAAAAAAAAAg".to_string()], vec!["p".to_string(), "farm_pubkey".to_string()], - vec!["a".to_string(), "30340:farm_pubkey:AAAAAAAAAAAAAAAAAAAAAA".to_string()], + vec![ + "a".to_string(), + "30340:farm_pubkey:AAAAAAAAAAAAAAAAAAAAAA".to_string(), + ], ]; let err = listing_from_event(KIND_POST, &tags, &content).unwrap_err(); @@ -235,8 +242,7 @@ fn listing_build_tags_includes_listing_fields() { && t.get(1).map(|s| s.as_str()) == Some("30340:farm_pubkey:AAAAAAAAAAAAAAAAAAAAAA") })); assert!(tags.iter().any(|t| { - t.get(0).map(|s| s.as_str()) == Some("key") - && t.get(1).map(|s| s.as_str()) == Some("sku") + t.get(0).map(|s| s.as_str()) == Some("key") && t.get(1).map(|s| s.as_str()) == Some("sku") })); assert!(tags.iter().any(|t| { t.get(0).map(|s| s.as_str()) == Some("title") @@ -285,10 +291,12 @@ fn listing_build_tags_includes_listing_fields() { .iter() .find(|t| t.get(0).map(|s| s.as_str()) == Some("radroots:discount")) .expect("discount tag"); - assert!(discount_tag - .get(1) - .map(|s| s.contains("\"scope\":\"bin\"")) - .unwrap_or(false)); + assert!( + discount_tag + .get(1) + .map(|s| s.contains("\"scope\":\"bin\"")) + .unwrap_or(false) + ); assert!(tags.iter().any(|t| { t.get(0).map(|s| s.as_str()) == Some("location") @@ -306,20 +314,16 @@ fn listing_build_tags_includes_listing_fields() { assert_eq!(tag[1].len(), full_len - idx); } assert!(tags.iter().any(|t| { - t.get(0).map(|s| s.as_str()) == Some("L") - && t.get(1).map(|s| s.as_str()) == Some("dd.lat") + t.get(0).map(|s| s.as_str()) == Some("L") && t.get(1).map(|s| s.as_str()) == Some("dd.lat") })); assert!(tags.iter().any(|t| { - t.get(0).map(|s| s.as_str()) == Some("L") - && t.get(1).map(|s| s.as_str()) == Some("dd.lon") + t.get(0).map(|s| s.as_str()) == Some("L") && t.get(1).map(|s| s.as_str()) == Some("dd.lon") })); assert!(tags.iter().any(|t| { - t.get(0).map(|s| s.as_str()) == Some("l") - && t.get(2).map(|s| s.as_str()) == Some("dd.lat") + t.get(0).map(|s| s.as_str()) == Some("l") && t.get(2).map(|s| s.as_str()) == Some("dd.lat") })); assert!(tags.iter().any(|t| { - t.get(0).map(|s| s.as_str()) == Some("l") - && t.get(2).map(|s| s.as_str()) == Some("dd.lon") + t.get(0).map(|s| s.as_str()) == Some("l") && t.get(2).map(|s| s.as_str()) == Some("dd.lon") })); assert!(tags.iter().any(|t| { @@ -400,7 +404,9 @@ fn listing_build_tags_ignores_null_strings() { }]); let tags = listing_build_tags(&listing).unwrap(); - assert!(!tags - .iter() - .any(|tag| tag.iter().any(|value| value == "null"))); + assert!( + !tags + .iter() + .any(|tag| tag.iter().any(|value| value == "null")) + ); } diff --git a/events-codec/tests/message.rs b/events-codec/tests/message.rs @@ -151,7 +151,10 @@ fn message_roundtrip_from_tags() { Some("wss://relay.example".to_string()) ); assert_eq!(message.content, "hello"); - assert_eq!(message.reply_to.as_ref().map(|r| r.id.as_str()), Some("reply")); + assert_eq!( + message.reply_to.as_ref().map(|r| r.id.as_str()), + Some("reply") + ); assert_eq!( message.reply_to.as_ref().and_then(|r| r.relays.as_deref()), Some("wss://reply.example") diff --git a/events-codec/tests/message_file.rs b/events-codec/tests/message_file.rs @@ -1,7 +1,7 @@ +use radroots_events::RadrootsNostrEventPtr; use radroots_events::kinds::{KIND_MESSAGE, KIND_MESSAGE_FILE}; use radroots_events::message::RadrootsMessageRecipient; use radroots_events::message_file::{RadrootsMessageFile, RadrootsMessageFileDimensions}; -use radroots_events::RadrootsNostrEventPtr; use radroots_events_codec::error::{EventEncodeError, EventParseError}; use radroots_events_codec::message_file::decode::message_file_from_tags; @@ -109,7 +109,10 @@ fn message_file_to_wire_parts_sets_kind_content_and_tags() { vec!["size".to_string(), "1200".to_string()], vec!["dim".to_string(), "1200x800".to_string()], vec!["blurhash".to_string(), "blurhash".to_string()], - vec!["thumb".to_string(), "https://files.example/thumb.bin".to_string()], + vec![ + "thumb".to_string(), + "https://files.example/thumb.bin".to_string() + ], vec![ "fallback".to_string(), "https://files.example/fallback-1.bin".to_string() diff --git a/events-codec/tests/post.rs b/events-codec/tests/post.rs @@ -1,4 +1,7 @@ -use radroots_events::{kinds::{KIND_COMMENT, KIND_POST}, post::RadrootsPost}; +use radroots_events::{ + kinds::{KIND_COMMENT, KIND_POST}, + post::RadrootsPost, +}; use radroots_events_codec::error::{EventEncodeError, EventParseError}; use radroots_events_codec::post::decode::post_from_content; use radroots_events_codec::post::encode::to_wire_parts; diff --git a/events-codec/tests/profile.rs b/events-codec/tests/profile.rs @@ -3,11 +3,8 @@ use radroots_events::{ kinds::KIND_POST, profile::{ - RadrootsProfileType, - RADROOTS_PROFILE_TYPE_TAG_ANY, - RADROOTS_PROFILE_TYPE_TAG_FARM, - RADROOTS_PROFILE_TYPE_TAG_KEY, - RADROOTS_PROFILE_TYPE_TAG_RADROOTSD, + RADROOTS_PROFILE_TYPE_TAG_ANY, RADROOTS_PROFILE_TYPE_TAG_FARM, + RADROOTS_PROFILE_TYPE_TAG_KEY, RADROOTS_PROFILE_TYPE_TAG_RADROOTSD, RadrootsProfileType, }, }; use radroots_events_codec::error::EventParseError; diff --git a/events-codec/tests/profile_encode.rs b/events-codec/tests/profile_encode.rs @@ -3,16 +3,12 @@ use radroots_events::{ kinds::KIND_PROFILE, profile::{ - RadrootsProfile, + RADROOTS_PROFILE_TYPE_TAG_FARM, RADROOTS_PROFILE_TYPE_TAG_KEY, RadrootsProfile, RadrootsProfileType, - RADROOTS_PROFILE_TYPE_TAG_FARM, - RADROOTS_PROFILE_TYPE_TAG_KEY, }, }; use radroots_events_codec::profile::encode::{ - to_metadata, - to_wire_parts, - to_wire_parts_with_profile_type, + to_metadata, to_wire_parts, to_wire_parts_with_profile_type, }; use radroots_events_codec::profile::error::ProfileEncodeError; use serde_json::Value; @@ -33,10 +29,7 @@ fn profile_to_metadata_rejects_invalid_url() { }; let err = to_metadata(&profile).unwrap_err(); - assert!(matches!( - err, - ProfileEncodeError::InvalidUrl("website", _) - )); + assert!(matches!(err, ProfileEncodeError::InvalidUrl("website", _))); } #[test] @@ -77,9 +70,7 @@ fn profile_to_wire_parts_with_profile_type_sets_tag() { }; let parts = to_wire_parts_with_profile_type(&profile, Some(RadrootsProfileType::Farm)).unwrap(); - assert!(parts - .tags - .iter() - .any(|tag| tag.get(0).map(|v| v.as_str()) == Some(RADROOTS_PROFILE_TYPE_TAG_KEY) - && tag.get(1).map(|v| v.as_str()) == Some(RADROOTS_PROFILE_TYPE_TAG_FARM))); + assert!(parts.tags.iter().any(|tag| tag.get(0).map(|v| v.as_str()) + == Some(RADROOTS_PROFILE_TYPE_TAG_KEY) + && tag.get(1).map(|v| v.as_str()) == Some(RADROOTS_PROFILE_TYPE_TAG_FARM))); } diff --git a/events-codec/tests/reaction.rs b/events-codec/tests/reaction.rs @@ -1,10 +1,10 @@ mod common; +use radroots_events::tags::TAG_E_ROOT; use radroots_events::{ kinds::{KIND_POST, KIND_REACTION}, reaction::RadrootsReaction, }; -use radroots_events::tags::TAG_E_ROOT; use radroots_events_codec::error::{EventEncodeError, EventParseError}; use radroots_events_codec::event_ref::{build_event_ref_tag, push_nip10_ref_tags}; diff --git a/events-codec/tests/relay_document.rs b/events-codec/tests/relay_document.rs @@ -18,5 +18,8 @@ fn relay_document_roundtrip_json() { #[test] fn relay_document_rejects_invalid_json() { let err = from_json("{").unwrap_err(); - assert!(matches!(err, EventParseError::InvalidJson("relay_document"))); + assert!(matches!( + err, + EventParseError::InvalidJson("relay_document") + )); } diff --git a/events-codec/tests/seal.rs b/events-codec/tests/seal.rs @@ -44,7 +44,11 @@ fn seal_from_parts_rejects_wrong_kind() { #[test] fn seal_from_parts_requires_empty_tags() { - let err = seal_from_parts(KIND_SEAL, &[vec!["p".to_string(), "x".to_string()]], "payload") - .unwrap_err(); + let err = seal_from_parts( + KIND_SEAL, + &[vec!["p".to_string(), "x".to_string()]], + "payload", + ) + .unwrap_err(); assert!(matches!(err, EventParseError::InvalidTag("tags"))); } diff --git a/events-codec/tests/wire.rs b/events-codec/tests/wire.rs @@ -1,5 +1,5 @@ use radroots_events::kinds::KIND_POST; -use radroots_events_codec::wire::{canonicalize_tags, empty_content, to_draft, WireEventParts}; +use radroots_events_codec::wire::{WireEventParts, canonicalize_tags, empty_content, to_draft}; #[test] fn canonicalize_tags_trims_sorts_and_dedups() {