use bytes::Bytes;
use serde::de::{self, MapAccess, SeqAccess, Visitor};
use serde::{Deserialize, Deserializer, Serialize};
use std::collections::BTreeMap;
use std::fmt;
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
#[non_exhaustive]
pub enum Body {
Text(String),
Markdown(String),
Html(String),
Xml(String),
Bytes(Bytes),
Screenshot(Bytes),
Fields(BTreeMap<String, serde_json::Value>),
WithFields {
content: Box<Body>,
fields: BTreeMap<String, serde_json::Value>,
},
Multi(MultiBody),
#[default]
Empty,
}
impl Body {
pub fn as_str(&self) -> Option<&str> {
match self {
Body::Text(s) | Body::Markdown(s) | Body::Html(s) | Body::Xml(s) => Some(s),
Body::Multi(m) => m.as_str(),
Body::WithFields { content, .. } => content.as_str(),
_ => None,
}
}
pub fn as_bytes(&self) -> Option<&Bytes> {
match self {
Body::Bytes(b) | Body::Screenshot(b) => Some(b),
Body::Multi(m) => m.bytes.as_ref().or(m.screenshot.as_ref()),
Body::WithFields { content, .. } => content.as_bytes(),
_ => None,
}
}
pub fn fields(&self) -> Option<&BTreeMap<String, serde_json::Value>> {
match self {
Body::Fields(f) | Body::WithFields { fields: f, .. } => Some(f),
_ => None,
}
}
pub fn is_empty(&self) -> bool {
match self {
Body::Empty => true,
Body::Text(s) | Body::Markdown(s) | Body::Html(s) | Body::Xml(s) => s.trim().is_empty(),
Body::Bytes(b) | Body::Screenshot(b) => b.is_empty(),
Body::Fields(f) => f.is_empty(),
Body::Multi(m) => m.is_empty(),
Body::WithFields { content, fields } => content.is_empty() && fields.is_empty(),
}
}
pub fn len(&self) -> usize {
match self {
Body::Empty => 0,
Body::Text(s) | Body::Markdown(s) | Body::Html(s) | Body::Xml(s) => s.len(),
Body::Bytes(b) | Body::Screenshot(b) => b.len(),
Body::Fields(f) => f.values().map(|v| v.to_string().len()).sum(),
Body::Multi(m) => m.len(),
Body::WithFields { content, fields } => {
content.len() + fields.values().map(|v| v.to_string().len()).sum::<usize>()
}
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
#[non_exhaustive]
pub struct MultiBody {
#[serde(skip_serializing_if = "Option::is_none")]
pub raw: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub bytes: Option<Bytes>,
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub markdown: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub html2text: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub screenshot: Option<Bytes>,
}
const MULTI_BODY_KEYS: &[&str] = &[
"raw",
"bytes",
"text",
"markdown",
"html2text",
"screenshot",
];
impl MultiBody {
pub fn as_str(&self) -> Option<&str> {
self.text
.as_deref()
.or(self.markdown.as_deref())
.or(self.html2text.as_deref())
.or(self.raw.as_deref())
}
pub fn is_empty(&self) -> bool {
let blank = |s: &Option<String>| s.as_ref().is_none_or(|s| s.trim().is_empty());
let no_bytes = |b: &Option<Bytes>| b.as_ref().is_none_or(|b| b.is_empty());
blank(&self.raw)
&& blank(&self.text)
&& blank(&self.markdown)
&& blank(&self.html2text)
&& no_bytes(&self.bytes)
&& no_bytes(&self.screenshot)
}
pub fn len(&self) -> usize {
let text = |s: &Option<String>| s.as_ref().map_or(0, |s| s.len());
let raw = |b: &Option<Bytes>| b.as_ref().map_or(0, |b| b.len());
text(&self.raw)
+ text(&self.text)
+ text(&self.markdown)
+ text(&self.html2text)
+ raw(&self.bytes)
+ raw(&self.screenshot)
}
pub fn present(&self) -> Vec<&'static str> {
let flags = [
self.raw.is_some(),
self.bytes.is_some(),
self.text.is_some(),
self.markdown.is_some(),
self.html2text.is_some(),
self.screenshot.is_some(),
];
MULTI_BODY_KEYS
.iter()
.zip(flags)
.filter(|(_, present)| *present)
.map(|(key, _)| *key)
.collect()
}
}
impl<'de> Deserialize<'de> for MultiBody {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_any(MultiBodyVisitor)
}
}
struct MultiBodyVisitor;
impl<'de> Visitor<'de> for MultiBodyVisitor {
type Value = MultiBody;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"page content as a string, as an array of bytes, or as an object with any of the keys {}",
MULTI_BODY_KEYS.join(", ")
)
}
fn visit_str<E: de::Error>(self, value: &str) -> Result<MultiBody, E> {
Ok(MultiBody {
raw: Some(value.to_owned()),
..MultiBody::default()
})
}
fn visit_string<E: de::Error>(self, value: String) -> Result<MultiBody, E> {
Ok(MultiBody {
raw: Some(value),
..MultiBody::default()
})
}
fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<MultiBody, E> {
Ok(MultiBody {
bytes: Some(Bytes::copy_from_slice(value)),
..MultiBody::default()
})
}
fn visit_byte_buf<E: de::Error>(self, value: Vec<u8>) -> Result<MultiBody, E> {
Ok(MultiBody {
bytes: Some(Bytes::from(value)),
..MultiBody::default()
})
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<MultiBody, A::Error> {
let mut buf: Vec<u8> = Vec::with_capacity(seq.size_hint().unwrap_or(0));
while let Some(byte) = seq.next_element::<u8>()? {
buf.push(byte);
}
Ok(MultiBody {
bytes: Some(Bytes::from(buf)),
..MultiBody::default()
})
}
fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<MultiBody, A::Error> {
let mut out = MultiBody::default();
while let Some(key) = map.next_key::<String>()? {
match key.as_str() {
"raw" => out.raw = map.next_value()?,
"bytes" => out.bytes = map.next_value()?,
"text" => out.text = map.next_value()?,
"markdown" => out.markdown = map.next_value()?,
"html2text" => out.html2text = map.next_value()?,
"screenshot" => out.screenshot = map.next_value()?,
other => {
log::debug!("content object carried an unknown key: {other}");
map.next_value::<de::IgnoredAny>()?;
}
}
}
Ok(out)
}
}
#[cfg(test)]
mod tests {
#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::panic,
clippy::unreachable,
clippy::indexing_slicing,
clippy::string_slice
)]
use super::*;
#[test]
fn reads_a_bare_string() {
let body: MultiBody = serde_json::from_str(r#""hello""#).expect("string content");
assert_eq!(body.raw.as_deref(), Some("hello"));
assert_eq!(body.as_str(), Some("hello"));
assert_eq!(body.present(), vec!["raw"]);
}
#[test]
fn reads_an_array_of_bytes() {
let body: MultiBody = serde_json::from_str("[104,105]").expect("byte array content");
assert_eq!(body.bytes.as_deref(), Some(&b"hi"[..]));
assert_eq!(body.as_str(), None);
assert_eq!(body.present(), vec!["bytes"]);
}
#[test]
fn reads_an_object() {
let body: MultiBody =
serde_json::from_str(r##"{"markdown":"# hi","raw":"<h1>hi</h1>"}"##).expect("object");
assert_eq!(body.markdown.as_deref(), Some("# hi"));
assert_eq!(body.raw.as_deref(), Some("<h1>hi</h1>"));
assert_eq!(body.as_str(), Some("# hi"));
assert_eq!(body.present(), vec!["raw", "markdown"]);
}
#[test]
fn an_unexpected_shape_says_what_it_got_and_what_it_wanted() {
let err = serde_json::from_str::<MultiBody>("42").expect_err("a number is not content");
let message = err.to_string();
assert!(message.contains("invalid type"), "{message}");
assert!(message.contains("42"), "{message}");
assert!(message.contains("array of bytes"), "{message}");
assert!(message.contains("html2text"), "{message}");
let err = serde_json::from_str::<MultiBody>("true").expect_err("a bool is not content");
assert!(err.to_string().contains("boolean"), "{err}");
}
#[test]
fn an_unknown_object_key_is_skipped_rather_than_fatal() {
let body: MultiBody =
serde_json::from_str(r#"{"text":"hi","some_new_format":{"a":1}}"#).expect("object");
assert_eq!(body.text.as_deref(), Some("hi"));
}
#[test]
fn empty_and_length_agree_with_what_is_there() {
assert!(MultiBody::default().is_empty());
assert!(serde_json::from_str::<MultiBody>(r#"" ""#)
.expect("blank")
.is_empty());
let body: MultiBody = serde_json::from_str(r#"{"text":"hi"}"#).expect("object");
assert!(!body.is_empty());
assert_eq!(body.len(), 2);
}
#[test]
fn body_reads_through_to_its_content() {
assert_eq!(Body::Markdown("# hi".into()).as_str(), Some("# hi"));
assert!(Body::Empty.is_empty());
assert!(Body::Text(" ".into()).is_empty());
assert_eq!(Body::Bytes(Bytes::from_static(b"abc")).len(), 3);
assert_eq!(Body::default(), Body::Empty);
assert_eq!(Body::Bytes(Bytes::from_static(b"abc")).as_str(), None);
let mut fields = BTreeMap::new();
fields.insert("price".to_string(), serde_json::json!("19.99"));
let body = Body::Fields(fields);
assert!(body.fields().is_some_and(|f| f.contains_key("price")));
assert!(!body.is_empty());
}
}