From ad16b10fc65815a513ccb18f93a95adcc58d901a Mon Sep 17 00:00:00 2001 From: Paul Z Date: Sun, 22 Oct 2023 20:45:48 +0200 Subject: [PATCH] provide basic responder functionality without serde, json features with serde feature --- Cargo.toml | 4 +- src/lib.rs | 2 - src/responders.rs | 178 +++++++++------------------------- src/responders/serde.rs | 205 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 252 insertions(+), 137 deletions(-) create mode 100644 src/responders/serde.rs diff --git a/Cargo.toml b/Cargo.toml index 026842c..5d2975a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,9 +11,9 @@ version = "0.3.1" edition = "2021" [features] -default = [ "responders" ] +default = [ ] guards = ["tower", "futures-core", "pin-project-lite"] -responders = ["serde", "serde_json"] +serde = [ "dep:serde", "dep:serde_json" ] [dependencies] axum = { git = "https://github.com/tokio-rs/axum", branch = "main", default-features = false } diff --git a/src/lib.rs b/src/lib.rs index 364a8f1..4dba053 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -4,7 +4,6 @@ pub mod extractors; #[cfg(feature = "guards")] pub mod guard; pub mod headers; -#[cfg(feature = "responders")] pub mod responders; use axum::{ @@ -15,5 +14,4 @@ pub use extractors::*; #[cfg(feature = "guards")] pub use guard::*; pub use headers::*; -#[cfg(feature = "responders")] pub use responders::*; diff --git a/src/responders.rs b/src/responders.rs index f1f68f6..b4247a7 100644 --- a/src/responders.rs +++ b/src/responders.rs @@ -1,16 +1,15 @@ -//pub struct HxLocation() - -use std::{collections::HashMap, convert::Infallible}; +use std::convert::Infallible; use axum::{ http::{header::InvalidHeaderValue, HeaderValue, StatusCode, Uri}, response::{IntoResponse, IntoResponseParts, ResponseParts}, }; -use serde::Serialize; -use serde_json::Value; use crate::headers; +#[cfg(feature = "serde")] +pub mod serde; + const HX_SWAP_INNER_HTML: &str = "innerHTML"; const HX_SWAP_OUTER_HTML: &str = "outerHTML"; const HX_SWAP_BEFORE_BEGIN: &str = "beforebegin"; @@ -22,62 +21,20 @@ const HX_SWAP_NONE: &str = "none"; /// The `HX-Location` header. /// -/// This response header can be used to trigger a client side redirection without reloading the whole page. Instead of changing the page’s location it will act like following a hx-boost link, creating a new history entry, issuing an ajax request to the value of the header and pushing the path into history. +/// This response header can be used to trigger a client side redirection without reloading the whole page. /// -/// -#[derive(Debug, Clone, Serialize)] -pub struct HxLocation { - /// Url to load the response from - pub path: String, - /// The source element of the request - pub source: Option, - /// An event that "triggered" the request - pub event: Option, - /// A callback that will handle the response HTML - pub handler: Option, - /// The target to swap the response into - pub target: Option, - /// How the response will be swapped in relative to the target - pub swap: Option, - /// Values to submit with the request - pub values: Option, - /// headers to submit with the request - pub headers: Option, -} - -impl HxLocation { - pub fn from_uri(uri: &Uri) -> Self { - Self { - path: uri.to_string(), - source: None, - event: None, - handler: None, - target: None, - swap: None, - values: None, - headers: None, - } - } -} +/// Will fail if the supplied Uri contains characters that are not visible ASCII (32-127). +#[derive(Debug, Clone)] +pub struct HxLocation(Uri); impl IntoResponseParts for HxLocation { type Error = HxError; fn into_response_parts(self, mut res: ResponseParts) -> Result { - let header_value = if self.source.is_none() - && self.event.is_none() - && self.handler.is_none() - && self.target.is_none() - && self.swap.is_none() - && self.values.is_none() - && self.headers.is_none() - { - HeaderValue::from_str(&self.path)? - } else { - HeaderValue::from_maybe_shared(serde_json::to_string(&self)?)? - }; - - res.headers_mut().insert(headers::HX_LOCATION, header_value); + res.headers_mut().insert( + headers::HX_LOCATION, + HeaderValue::from_maybe_shared(self.0.to_string())?, + ); Ok(res) } } @@ -226,16 +183,23 @@ impl IntoResponseParts for HxReselect { /// /// Allows you to trigger client-side events. /// -/// Will fail if the supplied events contain produce characters that are not visible ASCII (32-127) when serializing to json. +/// Will fail if the supplied events contain or produce characters that are not visible ASCII (32-127) when serializing to json. #[derive(Debug, Clone)] -pub struct HxTrigger(Vec); +pub struct HxTrigger(Vec); impl IntoResponseParts for HxTrigger { type Error = HxError; fn into_response_parts(self, mut res: ResponseParts) -> Result { - res.headers_mut() - .insert(headers::HX_TRIGGER, events_to_header_value(self.0)?); + res.headers_mut().insert( + headers::HX_TRIGGER, + HeaderValue::from_maybe_shared( + self.0 + .into_iter() + .reduce(|acc, e| acc + ", " + &e) + .unwrap_or_default(), + )?, + ); Ok(res) } } @@ -244,9 +208,9 @@ impl IntoResponseParts for HxTrigger { /// /// Allows you to trigger client-side events after the settle step. /// -/// Will fail if the supplied events contain produce characters that are not visible ASCII (32-127) when serializing to json. +/// Will fail if the supplied events contain or produce characters that are not visible ASCII (32-127) when serializing to json. #[derive(Debug, Clone)] -pub struct HxTriggerAfterSettle(Vec); +pub struct HxTriggerAfterSettle(Vec); impl IntoResponseParts for HxTriggerAfterSettle { type Error = HxError; @@ -254,7 +218,12 @@ impl IntoResponseParts for HxTriggerAfterSettle { fn into_response_parts(self, mut res: ResponseParts) -> Result { res.headers_mut().insert( headers::HX_TRIGGER_AFTER_SETTLE, - events_to_header_value(self.0)?, + HeaderValue::from_maybe_shared( + self.0 + .into_iter() + .reduce(|acc, e| acc + ", " + &e) + .unwrap_or_default(), + )?, ); Ok(res) } @@ -264,9 +233,9 @@ impl IntoResponseParts for HxTriggerAfterSettle { /// /// Allows you to trigger client-side events after the swap step. /// -/// Will fail if the supplied events contain produce characters that are not visible ASCII (32-127) when serializing to json. +/// Will fail if the supplied events contain or produce characters that are not visible ASCII (32-127) when serializing to json. #[derive(Debug, Clone)] -pub struct HxTriggerAfterSwap(Vec); +pub struct HxTriggerAfterSwap(Vec); impl IntoResponseParts for HxTriggerAfterSwap { type Error = HxError; @@ -274,13 +243,19 @@ impl IntoResponseParts for HxTriggerAfterSwap { fn into_response_parts(self, mut res: ResponseParts) -> Result { res.headers_mut().insert( headers::HX_TRIGGER_AFTER_SWAP, - events_to_header_value(self.0)?, + HeaderValue::from_maybe_shared( + self.0 + .into_iter() + .reduce(|acc, e| acc + ", " + &e) + .unwrap_or_default(), + )?, ); Ok(res) } } /// Values of the `hx-swap` attribute. +// serde::Serialize is implemented in responders/serde.rs #[derive(Debug, Copy, Clone)] pub enum SwapOption { /// Replace the inner html of the target element. @@ -316,76 +291,10 @@ impl From for HeaderValue { } } -// can be removed and automatically derived when https://github.com/serde-rs/serde/issues/2485 -// is implemented -impl Serialize for SwapOption { - fn serialize(&self, serializer: S) -> Result - where - S: serde::Serializer, - { - const UNIT_NAME: &str = "SwapOption"; - match self { - Self::InnerHtml => serializer.serialize_unit_variant(UNIT_NAME, 0, HX_SWAP_INNER_HTML), - Self::OuterHtml => serializer.serialize_unit_variant(UNIT_NAME, 1, HX_SWAP_OUTER_HTML), - Self::BeforeBegin => { - serializer.serialize_unit_variant(UNIT_NAME, 2, HX_SWAP_BEFORE_BEGIN) - } - Self::AfterBegin => { - serializer.serialize_unit_variant(UNIT_NAME, 3, HX_SWAP_AFTER_BEGIN) - } - Self::BeforeEnd => serializer.serialize_unit_variant(UNIT_NAME, 4, HX_SWAP_BEFORE_END), - Self::AfterEnd => serializer.serialize_unit_variant(UNIT_NAME, 5, HX_SWAP_AFTER_END), - Self::Delete => serializer.serialize_unit_variant(UNIT_NAME, 6, HX_SWAP_DELETE), - Self::None => serializer.serialize_unit_variant(UNIT_NAME, 7, HX_SWAP_NONE), - } - } -} - -#[derive(Debug, Clone, Serialize)] -pub struct HxEvent { - pub name: String, - pub data: Option, -} - -impl HxEvent { - pub fn new(name: String) -> Self { - Self { name, data: None } - } - pub fn new_with_data(name: String, data: T) -> Result { - let data = serde_json::to_value(data)?; - - Ok(Self { - name, - data: Some(data), - }) - } -} - -pub(crate) fn events_to_header_value(events: Vec) -> Result { - let with_data = events.iter().any(|e| e.data.is_some()); - - let header_value = if with_data { - // at least one event contains data so the header_value needs to be json encoded. - let header_value = events - .into_iter() - .map(|e| (e.name, e.data.map(|d| d.to_string()).unwrap_or_default())) - .collect::>(); - serde_json::to_string(&header_value)? - } else { - // no event contains data, the event names can be put in the header value separated - // by a comma. - events - .into_iter() - .map(|e| e.name) - .reduce(|acc, e| acc + ", " + &e) - .unwrap_or_default() - }; - - HeaderValue::from_maybe_shared(header_value).map_err(HxError::from) -} - pub enum HxError { InvalidHeaderValue(InvalidHeaderValue), + + #[cfg(feature = "serde")] Serialization(serde_json::Error), } @@ -395,6 +304,7 @@ impl From for HxError { } } +#[cfg(feature = "serde")] impl From for HxError { fn from(value: serde_json::Error) -> Self { Self::Serialization(value) @@ -407,6 +317,8 @@ impl IntoResponse for HxError { Self::InvalidHeaderValue(_) => { (StatusCode::INTERNAL_SERVER_ERROR, "invalid header value").into_response() } + + #[cfg(feature = "serde")] Self::Serialization(_) => ( StatusCode::INTERNAL_SERVER_ERROR, "failed to serialize event", diff --git a/src/responders/serde.rs b/src/responders/serde.rs new file mode 100644 index 0000000..dc3c8c3 --- /dev/null +++ b/src/responders/serde.rs @@ -0,0 +1,205 @@ +use std::collections::HashMap; + +use axum::{ + http::{HeaderValue, Uri}, + response::{IntoResponseParts, ResponseParts}, +}; +use serde::Serialize; +use serde_json::Value; + +use crate::{ + headers, + responders::{ + HX_SWAP_AFTER_BEGIN, HX_SWAP_AFTER_END, HX_SWAP_BEFORE_BEGIN, HX_SWAP_BEFORE_END, + HX_SWAP_DELETE, HX_SWAP_INNER_HTML, HX_SWAP_NONE, HX_SWAP_OUTER_HTML, + }, + HxError, SwapOption, +}; + +/// The `HX-Location` header. +/// +/// This response header can be used to trigger a client side redirection without reloading the whole page. Instead of changing the page’s location it will act like following a hx-boost link, creating a new history entry, issuing an ajax request to the value of the header and pushing the path into history. +/// +/// Will fail if the supplied data contains or produces characters that are not visible ASCII (32-127) when serializing to json. +#[derive(Debug, Clone, Serialize)] +pub struct HxLocation { + /// Url to load the response from + pub path: String, + /// The source element of the request + pub source: Option, + /// An event that "triggered" the request + pub event: Option, + /// A callback that will handle the response HTML + pub handler: Option, + /// The target to swap the response into + pub target: Option, + /// How the response will be swapped in relative to the target + pub swap: Option, + /// Values to submit with the request + pub values: Option, + /// headers to submit with the request + pub headers: Option, +} + +impl HxLocation { + pub fn from_uri(uri: &Uri) -> Self { + Self { + path: uri.to_string(), + source: None, + event: None, + handler: None, + target: None, + swap: None, + values: None, + headers: None, + } + } +} + +impl IntoResponseParts for HxLocation { + type Error = HxError; + + fn into_response_parts(self, mut res: ResponseParts) -> Result { + let header_value = if self.source.is_none() + && self.event.is_none() + && self.handler.is_none() + && self.target.is_none() + && self.swap.is_none() + && self.values.is_none() + && self.headers.is_none() + { + HeaderValue::from_str(&self.path)? + } else { + HeaderValue::from_maybe_shared(serde_json::to_string(&self)?)? + }; + + res.headers_mut().insert(headers::HX_LOCATION, header_value); + Ok(res) + } +} + +/// The `HX-Trigger` header. +/// +/// Allows you to trigger client-side events. +/// +/// Will fail if the supplied events contain or produce characters that are not visible ASCII (32-127) when serializing to json. +#[derive(Debug, Clone)] +pub struct HxTrigger(Vec); + +impl IntoResponseParts for HxTrigger { + type Error = HxError; + + fn into_response_parts(self, mut res: ResponseParts) -> Result { + res.headers_mut() + .insert(headers::HX_TRIGGER, events_to_header_value(self.0)?); + Ok(res) + } +} + +/// The `HX-Trigger-After-Settle` header. +/// +/// Allows you to trigger client-side events after the settle step. +/// +/// Will fail if the supplied events contain or produce characters that are not visible ASCII (32-127) when serializing to json. +#[derive(Debug, Clone)] +pub struct HxTriggerAfterSettle(Vec); + +impl IntoResponseParts for HxTriggerAfterSettle { + type Error = HxError; + + fn into_response_parts(self, mut res: ResponseParts) -> Result { + res.headers_mut().insert( + headers::HX_TRIGGER_AFTER_SETTLE, + events_to_header_value(self.0)?, + ); + Ok(res) + } +} + +/// The `HX-Trigger-After-Swap` header. +/// +/// Allows you to trigger client-side events after the swap step. +/// +/// Will fail if the supplied events contain or produce characters that are not visible ASCII (32-127) when serializing to json. +#[derive(Debug, Clone)] +pub struct HxTriggerAfterSwap(Vec); + +impl IntoResponseParts for HxTriggerAfterSwap { + type Error = HxError; + + fn into_response_parts(self, mut res: ResponseParts) -> Result { + res.headers_mut().insert( + headers::HX_TRIGGER_AFTER_SWAP, + events_to_header_value(self.0)?, + ); + Ok(res) + } +} + +#[derive(Debug, Clone, Serialize)] +pub struct HxEvent { + pub name: String, + pub data: Option, +} + +impl HxEvent { + pub fn new(name: String) -> Self { + Self { name, data: None } + } + pub fn new_with_data(name: String, data: T) -> Result { + let data = serde_json::to_value(data)?; + + Ok(Self { + name, + data: Some(data), + }) + } +} + +pub(crate) fn events_to_header_value(events: Vec) -> Result { + let with_data = events.iter().any(|e| e.data.is_some()); + + let header_value = if with_data { + // at least one event contains data so the header_value needs to be json encoded. + let header_value = events + .into_iter() + .map(|e| (e.name, e.data.map(|d| d.to_string()).unwrap_or_default())) + .collect::>(); + serde_json::to_string(&header_value)? + } else { + // no event contains data, the event names can be put in the header value separated + // by a comma. + events + .into_iter() + .map(|e| e.name) + .reduce(|acc, e| acc + ", " + &e) + .unwrap_or_default() + }; + + HeaderValue::from_maybe_shared(header_value).map_err(HxError::from) +} + +// can be removed and automatically derived when https://github.com/serde-rs/serde/issues/2485 +// is implemented +impl serde::Serialize for SwapOption { + fn serialize(&self, serializer: S) -> Result + where + S: serde::Serializer, + { + const UNIT_NAME: &str = "SwapOption"; + match self { + Self::InnerHtml => serializer.serialize_unit_variant(UNIT_NAME, 0, HX_SWAP_INNER_HTML), + Self::OuterHtml => serializer.serialize_unit_variant(UNIT_NAME, 1, HX_SWAP_OUTER_HTML), + Self::BeforeBegin => { + serializer.serialize_unit_variant(UNIT_NAME, 2, HX_SWAP_BEFORE_BEGIN) + } + Self::AfterBegin => { + serializer.serialize_unit_variant(UNIT_NAME, 3, HX_SWAP_AFTER_BEGIN) + } + Self::BeforeEnd => serializer.serialize_unit_variant(UNIT_NAME, 4, HX_SWAP_BEFORE_END), + Self::AfterEnd => serializer.serialize_unit_variant(UNIT_NAME, 5, HX_SWAP_AFTER_END), + Self::Delete => serializer.serialize_unit_variant(UNIT_NAME, 6, HX_SWAP_DELETE), + Self::None => serializer.serialize_unit_variant(UNIT_NAME, 7, HX_SWAP_NONE), + } + } +}