use std::borrow::Cow;
use std::convert::{Infallible, TryFrom};
use std::error::Error;
use std::fmt::{self, Display, Formatter};
use std::hash::{Hash, Hasher};
use std::ops::Deref;
use std::str;
use crate::utility::{
get_percent_encoded_value, normalize_string, percent_encoded_equality, percent_encoded_hash,
UNRESERVED_CHAR_MAP,
};
#[rustfmt::skip]
const FRAGMENT_CHAR_MAP: [u8; 256] = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, b'!', 0, 0, b'$', b'%', b'&',b'\'', b'(', b')', b'*', b'+', b',', b'-', b'.', b'/',
b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b':', b';', 0, b'=', 0, b'?',
b'@', b'A', b'B', b'C', b'D', b'E', b'F', b'G', b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O',
b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W', b'X', b'Y', b'Z', 0, 0, 0, 0, b'_',
0, b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',
b'p', b'q', b'r', b's', b't', b'u', b'v', b'w', b'x', b'y', b'z', 0, 0, 0, b'~', 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
];
#[derive(Clone, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Fragment<'fragment> {
fragment: Cow<'fragment, str>,
normalized: bool,
}
impl Fragment<'_> {
pub fn as_borrowed(&self) -> Fragment {
use self::Cow::*;
let fragment = match &self.fragment {
Borrowed(borrowed) => *borrowed,
Owned(owned) => owned.as_str(),
};
Fragment {
fragment: Cow::Borrowed(fragment),
normalized: self.normalized,
}
}
pub fn as_str(&self) -> &str {
&self.fragment
}
pub fn into_owned(self) -> Fragment<'static> {
Fragment {
fragment: Cow::from(self.fragment.into_owned()),
normalized: self.normalized,
}
}
pub fn is_normalized(&self) -> bool {
self.normalized
}
pub fn normalize(&mut self) {
if !self.normalized {
unsafe { normalize_string(&mut self.fragment.to_mut(), true) };
self.normalized = true;
}
}
}
impl AsRef<[u8]> for Fragment<'_> {
fn as_ref(&self) -> &[u8] {
self.fragment.as_bytes()
}
}
impl AsRef<str> for Fragment<'_> {
fn as_ref(&self) -> &str {
&self.fragment
}
}
impl Deref for Fragment<'_> {
type Target = str;
fn deref(&self) -> &Self::Target {
&self.fragment
}
}
impl Display for Fragment<'_> {
fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
formatter.write_str(&self.fragment)
}
}
impl Eq for Fragment<'_> {}
impl<'fragment> From<Fragment<'fragment>> for String {
fn from(value: Fragment<'fragment>) -> Self {
value.to_string()
}
}
impl Hash for Fragment<'_> {
fn hash<H>(&self, state: &mut H)
where
H: Hasher,
{
percent_encoded_hash(self.fragment.as_bytes(), state, true);
}
}
impl PartialEq for Fragment<'_> {
fn eq(&self, other: &Fragment) -> bool {
percent_encoded_equality(self.fragment.as_bytes(), other.fragment.as_bytes(), true)
}
}
impl PartialEq<[u8]> for Fragment<'_> {
fn eq(&self, other: &[u8]) -> bool {
percent_encoded_equality(self.fragment.as_bytes(), other, true)
}
}
impl<'fragment> PartialEq<Fragment<'fragment>> for [u8] {
fn eq(&self, other: &Fragment<'fragment>) -> bool {
percent_encoded_equality(self, other.fragment.as_bytes(), true)
}
}
impl<'a> PartialEq<&'a [u8]> for Fragment<'_> {
fn eq(&self, other: &&'a [u8]) -> bool {
percent_encoded_equality(self.fragment.as_bytes(), other, true)
}
}
impl<'a, 'fragment> PartialEq<Fragment<'fragment>> for &'a [u8] {
fn eq(&self, other: &Fragment<'fragment>) -> bool {
percent_encoded_equality(self, other.fragment.as_bytes(), true)
}
}
impl PartialEq<str> for Fragment<'_> {
fn eq(&self, other: &str) -> bool {
percent_encoded_equality(self.fragment.as_bytes(), other.as_bytes(), true)
}
}
impl<'fragment> PartialEq<Fragment<'fragment>> for str {
fn eq(&self, other: &Fragment<'fragment>) -> bool {
percent_encoded_equality(self.as_bytes(), other.fragment.as_bytes(), true)
}
}
impl<'a> PartialEq<&'a str> for Fragment<'_> {
fn eq(&self, other: &&'a str) -> bool {
percent_encoded_equality(self.fragment.as_bytes(), other.as_bytes(), true)
}
}
impl<'a, 'fragment> PartialEq<Fragment<'fragment>> for &'a str {
fn eq(&self, other: &Fragment<'fragment>) -> bool {
percent_encoded_equality(self.as_bytes(), other.fragment.as_bytes(), true)
}
}
impl<'fragment> TryFrom<&'fragment [u8]> for Fragment<'fragment> {
type Error = FragmentError;
fn try_from(value: &'fragment [u8]) -> Result<Self, Self::Error> {
let mut bytes = value.iter();
let mut normalized = true;
while let Some(&byte) = bytes.next() {
match FRAGMENT_CHAR_MAP[byte as usize] {
0 => return Err(FragmentError::InvalidCharacter),
b'%' => {
match get_percent_encoded_value(bytes.next().cloned(), bytes.next().cloned()) {
Ok((hex_value, uppercase)) => {
if !uppercase || UNRESERVED_CHAR_MAP[hex_value as usize] != 0 {
normalized = false;
}
}
Err(_) => return Err(FragmentError::InvalidPercentEncoding),
}
}
_ => (),
}
}
Ok(Fragment {
fragment: Cow::from(unsafe { str::from_utf8_unchecked(value) }),
normalized,
})
}
}
impl<'fragment> TryFrom<&'fragment str> for Fragment<'fragment> {
type Error = FragmentError;
fn try_from(value: &'fragment str) -> Result<Self, Self::Error> {
Fragment::try_from(value.as_bytes())
}
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
#[non_exhaustive]
pub enum FragmentError {
InvalidCharacter,
InvalidPercentEncoding,
}
impl Display for FragmentError {
fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
use self::FragmentError::*;
match self {
InvalidCharacter => write!(formatter, "invalid fragment character"),
InvalidPercentEncoding => write!(formatter, "invalid fragment percent encoding"),
}
}
}
impl Error for FragmentError {}
impl From<Infallible> for FragmentError {
fn from(_: Infallible) -> Self {
FragmentError::InvalidCharacter
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_fragment_normalize() {
fn test_case(value: &str, expected: &str) {
let mut fragment = Fragment::try_from(value).unwrap();
fragment.normalize();
assert_eq!(fragment, expected);
}
test_case("", "");
test_case("%ff", "%FF");
test_case("%41", "A");
}
#[test]
fn test_fragment_parse() {
use self::FragmentError::*;
assert_eq!(Fragment::try_from("").unwrap(), "");
assert_eq!(Fragment::try_from("fragment").unwrap(), "fragment");
assert_eq!(Fragment::try_from("fRaGmEnT").unwrap(), "fRaGmEnT");
assert_eq!(Fragment::try_from("%ff%ff%ff%41").unwrap(), "%ff%ff%ff%41");
assert_eq!(Fragment::try_from(" "), Err(InvalidCharacter));
assert_eq!(Fragment::try_from("%"), Err(InvalidPercentEncoding));
assert_eq!(Fragment::try_from("%f"), Err(InvalidPercentEncoding));
assert_eq!(Fragment::try_from("%zz"), Err(InvalidPercentEncoding));
}
}