#![no_std]
#![doc(html_root_url = "https://docs.rs/vary-header/0.1.0")]
extern crate alloc;
use alloc::format;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
#[cfg(doctest)]
#[doc = include_str!("../README.md")]
struct ReadmeDoctests;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum VaryError {
FieldRequired,
InvalidFieldName(String),
}
impl core::fmt::Display for VaryError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
VaryError::FieldRequired => f.write_str("field argument is required"),
VaryError::InvalidFieldName(name) => {
write!(f, "field argument contains an invalid header name: {name}")
}
}
}
}
impl core::error::Error for VaryError {}
pub fn append(header: &str, field: &str) -> Result<String, VaryError> {
if field.is_empty() {
return Err(VaryError::FieldRequired);
}
let fields = parse(field);
append_impl(header, &fields)
}
pub fn append_fields(header: &str, fields: &[&str]) -> Result<String, VaryError> {
let owned: Vec<String> = fields.iter().map(|s| (*s).to_string()).collect();
append_impl(header, &owned)
}
fn append_impl(header: &str, fields: &[String]) -> Result<String, VaryError> {
for field in fields {
if !is_field_name(field) {
return Err(VaryError::InvalidFieldName(field.clone()));
}
}
if header == "*" {
return Ok("*".to_string());
}
let mut val = header.to_string();
let mut vals = parse(&lowercase(header));
if fields.iter().any(|f| f == "*") || vals.iter().any(|v| v == "*") {
return Ok("*".to_string());
}
for field in fields {
let fld = lowercase(field);
if !vals.contains(&fld) {
vals.push(fld);
val = if val.is_empty() {
field.clone()
} else {
format!("{val}, {field}")
};
}
}
Ok(val)
}
fn parse(header: &str) -> Vec<String> {
let chars: Vec<char> = header.chars().collect();
let mut list = Vec::new();
let mut start = 0;
let mut end = 0;
for (i, &c) in chars.iter().enumerate() {
match c {
' ' => {
if start == end {
start = i + 1;
end = i + 1;
}
}
',' => {
list.push(chars[start..end].iter().collect());
start = i + 1;
end = i + 1;
}
_ => end = i + 1,
}
}
list.push(chars[start..end].iter().collect());
list
}
fn lowercase(s: &str) -> String {
s.chars().flat_map(char::to_lowercase).collect()
}
fn is_field_name(s: &str) -> bool {
!s.is_empty() && s.chars().all(is_tchar)
}
fn is_tchar(c: char) -> bool {
c.is_ascii_alphanumeric()
|| matches!(
c,
'!' | '#'
| '$'
| '%'
| '&'
| '\''
| '*'
| '+'
| '-'
| '.'
| '^'
| '_'
| '`'
| '|'
| '~'
)
}