use std::any::Any;
use std::borrow::Cow;
use std::{ops::Div, str::FromStr};
use ntex_bytes::{ByteString, Bytes};
use simdutf8::compat::{Utf8Error, from_utf8};
use crate::authority::{self, Authority, Port, UserInfo};
use crate::chars::lowercase;
use crate::error::{ErrorKind, InvalidUrl};
use crate::host::normalize_host;
use crate::parse::{
self, MAX_LEN, has_dot_segments, join_authority, normalize_authority, normalize_path,
remove_dot_segments,
};
use crate::path::{Path, PathAndQuery};
use crate::query::{self, Fragment, Query, split_pair};
use crate::quoting::{Component, quote_cow, unquote_cow};
use crate::scheme::Scheme;
#[derive(Clone)]
pub struct Url {
data: ByteString,
scheme_end: u16,
auth_start: u16,
path_start: u16,
path_end: u16,
query_end: u16,
}
#[derive(Copy, Clone, Default)]
pub(crate) struct Components<'a> {
pub(crate) scheme: Option<&'a str>,
pub(crate) authority: Option<&'a str>,
pub(crate) path: &'a str,
pub(crate) query: Option<&'a str>,
pub(crate) fragment: Option<&'a str>,
}
pub(crate) fn assemble(c: &Components<'_>, orig: Option<&ByteString>) -> Result<Url, InvalidUrl> {
let prefix = if c.authority.is_some() {
if c.path.is_empty() {
let special = c
.scheme
.is_some_and(|s| Scheme::from_str_unchecked(s).is_special());
if special { "/" } else { "" }
} else if c.path.starts_with('/') {
""
} else {
"/"
}
} else if c.path.starts_with("//") {
"/."
} else if c.scheme.is_none() && c.path.split('/').next().is_some_and(|s| s.contains(':')) {
"./"
} else {
""
};
let pieces = [
c.scheme.unwrap_or(""),
if c.scheme.is_some() { ":" } else { "" },
if c.authority.is_some() { "//" } else { "" },
c.authority.unwrap_or(""),
prefix,
c.path,
if c.query.is_some() { "?" } else { "" },
c.query.unwrap_or(""),
if c.fragment.is_some() { "#" } else { "" },
c.fragment.unwrap_or(""),
];
let len: usize = pieces.iter().map(|p| p.len()).sum();
if len > MAX_LEN {
return Err(InvalidUrl::new(ErrorKind::TooLong));
}
let reuse = orig.filter(|orig| {
orig.len() == len && {
let mut rest = orig.as_str();
pieces.iter().all(|p| match rest.strip_prefix(p) {
Some(r) => {
rest = r;
true
}
None => false,
})
}
});
let data = match reuse {
Some(orig) => orig.clone(),
None => ByteString::from(pieces.concat()),
};
let lens = pieces.map(|p| p.len() as u16);
let scheme_end = lens[0];
let auth_start = if c.authority.is_some() {
lens[0] + lens[1] + lens[2]
} else {
0
};
let path_start = lens[..4].iter().sum::<u16>();
let path_end = path_start + lens[4] + lens[5];
let query_end = path_end + lens[6] + lens[7];
Ok(Url {
data,
scheme_end,
auth_start,
path_start,
path_end,
query_end,
})
}
fn too_long<T>(res: Result<T, InvalidUrl>) -> T {
match res {
Ok(v) => v,
Err(e) => panic!("{e}"),
}
}
impl Url {
pub fn parse<T: AsRef<str>>(src: T) -> Result<Url, InvalidUrl> {
parse::parse(src.as_ref(), None)
}
pub fn validate<T: AsRef<[u8]>>(src: T) -> Result<(), InvalidUrl> {
let src = src.as_ref();
if let Ok(s) = from_utf8(src) {
return parse::validate(s);
}
let i = src.iter().position(|b| !b.is_ascii()).unwrap_or_default();
let c = src[i..]
.utf8_chunks()
.next()
.and_then(|chunk| chunk.valid().chars().next())
.unwrap_or(char::REPLACEMENT_CHARACTER);
Err(InvalidUrl::at(ErrorKind::InvalidChar(c), i))
}
pub fn from_static(src: &'static str) -> Url {
match parse::parse(src, Some(&ByteString::from_static(src))) {
Ok(url) => url,
Err(e) => panic!("invalid static url {src:?}: {e}"),
}
}
pub fn from_maybe_shared<T>(src: T) -> Result<Url, InvalidUrl>
where
T: AsRef<[u8]> + 'static,
{
let mut src = Some(src);
let any = &mut src as &mut dyn Any;
if let Some(src) = any.downcast_mut::<Option<ByteString>>() {
return Url::try_from(src.take().unwrap());
}
if let Some(src) = any.downcast_mut::<Option<Bytes>>() {
return Url::try_from(src.take().unwrap());
}
if let Some(src) = any.downcast_mut::<Option<String>>() {
return Url::try_from(src.take().unwrap());
}
if let Some(src) = any.downcast_mut::<Option<Vec<u8>>>() {
return Url::try_from(Bytes::from(src.take().unwrap()));
}
Url::try_from(src.unwrap().as_ref())
}
pub fn builder() -> crate::Builder {
crate::Builder::new()
}
pub(crate) fn empty() -> Url {
Url {
data: ByteString::new(),
scheme_end: 0,
auth_start: 0,
path_start: 0,
path_end: 0,
query_end: 0,
}
}
fn components(&self) -> Components<'_> {
Components {
scheme: self.scheme_str(),
authority: self.authority().map(Authority::as_str),
path: self.path().as_str(),
query: self.query().map(Query::as_str),
fragment: self.fragment().map(Fragment::as_str),
}
}
fn range(&self, start: u16, end: u16) -> &str {
&self.data[start as usize..end as usize]
}
pub fn as_str(&self) -> &str {
&self.data
}
pub fn as_bytes(&self) -> &[u8] {
self.data.as_bytes()
}
pub fn as_byte_string(&self) -> &ByteString {
&self.data
}
pub fn scheme(&self) -> Option<&Scheme> {
self.scheme_str().map(Scheme::from_str_unchecked)
}
pub fn scheme_str(&self) -> Option<&str> {
(self.scheme_end > 0).then(|| self.range(0, self.scheme_end))
}
pub fn authority(&self) -> Option<&Authority> {
(self.auth_start > 0)
.then(|| Authority::from_str_unchecked(self.range(self.auth_start, self.path_start)))
}
pub fn userinfo(&self) -> Option<&UserInfo> {
self.authority()?.userinfo()
}
pub fn username(&self) -> Option<ByteString> {
self.userinfo().map(UserInfo::decoded_username)
}
pub fn password(&self) -> Option<ByteString> {
self.userinfo()?.decoded_password()
}
pub fn host(&self) -> Option<&str> {
self.authority()
.map(Authority::host)
.filter(|h| !h.is_empty())
}
pub fn host_parsed(&self) -> Option<crate::Host<'_>> {
self.host().map(crate::Host::classify)
}
pub fn port(&self) -> Option<Port<&str>> {
self.authority()?.port()
}
pub fn port_u16(&self) -> Option<u16> {
self.port().map(|p| p.as_u16())
}
pub fn port_or_known_default(&self) -> Option<u16> {
self.port_u16().or_else(|| self.scheme()?.default_port())
}
pub fn path(&self) -> &Path {
Path::from_str_unchecked(self.range(self.path_start, self.path_end))
}
pub fn query(&self) -> Option<&Query> {
(self.query_end > self.path_end)
.then(|| Query::from_str_unchecked(self.range(self.path_end + 1, self.query_end)))
}
pub fn path_and_query(&self) -> &PathAndQuery {
PathAndQuery::from_str_unchecked(self.range(self.path_start, self.query_end))
}
pub fn fragment(&self) -> Option<&Fragment> {
((self.query_end as usize) < self.data.len())
.then(|| Fragment::from_str_unchecked(&self.data[self.query_end as usize + 1..]))
}
pub fn is_absolute(&self) -> bool {
self.scheme_end > 0
}
pub fn is_default_port(&self) -> bool {
match self.port_u16() {
None => true,
Some(port) => self.scheme().and_then(Scheme::default_port) == Some(port),
}
}
pub fn origin(&self) -> Option<Url> {
let scheme = self.scheme_str()?;
let authority = self.authority()?;
if authority.host().is_empty() {
return None;
}
Some(self.derive(|c| {
*c = Components {
scheme: Some(scheme),
authority: Some(authority.host_port()),
..Components::default()
};
}))
}
pub fn relative(&self) -> Url {
self.derive(|c| {
c.scheme = None;
c.authority = None;
})
}
pub fn parent(&self) -> Url {
let path = self.path().as_str();
let trimmed = path.trim_end_matches('/');
let parent = match trimmed.rfind('/') {
Some(0) => "/",
Some(i) => &trimmed[..i],
None if path.starts_with('/') => "/",
None => "",
};
self.with_path(parent)
}
pub fn push_segments<I, S>(&self, segments: I) -> Url
where
I: IntoIterator<Item = S>,
S: AsRef<str>,
{
let mut path = self.path().as_str().to_string();
for segment in segments {
let segment = segment.as_ref();
let segment = segment.strip_prefix('/').unwrap_or(segment);
if !path.is_empty() && !path.ends_with('/') {
path.push('/');
}
path.push_str("e_cow(segment, Component::Path, false));
}
if path.starts_with('/') && has_dot_segments(&path) {
path = remove_dot_segments(&path);
}
self.with_path(&path)
}
pub fn join(&self, reference: &str) -> Result<Url, InvalidUrl> {
if reference.trim_matches(|c: char| c <= ' ').is_empty() {
return self.rebuild(|c| c.fragment = None);
}
Ok(self.join_url(&Url::parse(reference)?))
}
pub fn join_url(&self, r: &Url) -> Url {
let base = self.components();
let r = r.components();
let resolved = |path| Cow::Owned(remove_dot_segments(path));
let (scheme, authority, path, query) = if r.scheme.is_some() {
(r.scheme, r.authority, resolved(r.path), r.query)
} else if r.authority.is_some() {
(base.scheme, r.authority, resolved(r.path), r.query)
} else if r.path.is_empty() {
let query = r.query.or(base.query);
(base.scheme, base.authority, Cow::Borrowed(base.path), query)
} else if r.path.starts_with('/') {
(base.scheme, base.authority, resolved(r.path), r.query)
} else {
let dir = if base.authority.is_some() && base.path.is_empty() {
"/"
} else {
dir(base.path)
};
let path = resolved(&format!("{dir}{}", r.path));
(base.scheme, base.authority, path, r.query)
};
self.derive(|c| {
*c = Components {
scheme,
authority,
path: &path,
query,
fragment: r.fragment,
};
})
}
fn rebuild<'a>(&'a self, f: impl FnOnce(&mut Components<'a>)) -> Result<Url, InvalidUrl> {
let mut c = self.components();
f(&mut c);
assemble(&c, Some(&self.data))
}
fn derive<'a>(&'a self, f: impl FnOnce(&mut Components<'a>)) -> Url {
too_long(self.rebuild(f))
}
fn with_path(&self, path: &str) -> Url {
self.derive(|c| {
c.path = path;
c.query = None;
c.fragment = None;
})
}
pub fn set_scheme(&mut self, scheme: &str) -> Result<(), InvalidUrl> {
let scheme = lowercase(Scheme::new(scheme)?.as_str().into());
self.rebuild(|c| c.scheme = Some(&scheme))
.map(|url| *self = url)
}
pub fn set_authority(&mut self, authority: Option<&str>) -> Result<(), InvalidUrl> {
let authority = authority.map(normalize_authority).transpose()?;
self.rebuild(|c| c.authority = authority.as_deref())
.map(|url| *self = url)
}
fn with_authority(
&self,
userinfo: Option<&str>,
host: &str,
port: Option<u16>,
) -> Result<Url, InvalidUrl> {
let authority = join_authority(userinfo, host, port);
self.rebuild(|c| c.authority = Some(&authority))
}
fn host_parts(&self) -> Result<(Option<&str>, &str, Option<u16>), InvalidUrl> {
let authority = self
.authority()
.ok_or(InvalidUrl::new(ErrorKind::AuthorityMissing))?;
let (userinfo, host, _) = authority::split(authority.as_str());
if host.is_empty() {
return Err(InvalidUrl::new(ErrorKind::InvalidHost));
}
Ok((userinfo, host, authority.port_u16()))
}
pub fn set_userinfo(
&mut self,
username: Option<&str>,
password: Option<&str>,
) -> Result<(), InvalidUrl> {
let (_, host, port) = self.host_parts()?;
let userinfo = match (username, password) {
(None, None) => None,
(user, None) => Some(quote_cow(user.unwrap_or(""), Component::UserInfo, false)),
(user, Some(password)) => Some(Cow::Owned(format!(
"{}:{}",
quote_cow(user.unwrap_or(""), Component::UserInfo, false),
quote_cow(password, Component::UserInfo, false)
))),
};
self.with_authority(userinfo.as_deref(), host, port)
.map(|url| *self = url)
}
pub fn set_host(&mut self, host: &str) -> Result<(), InvalidUrl> {
let bracketed;
let host = if host.contains(':') && !host.starts_with('[') {
bracketed = format!("[{host}]");
&bracketed
} else {
host
};
let host = normalize_host(host)?;
if host.is_empty() {
return Err(InvalidUrl::new(ErrorKind::InvalidHost));
}
let (userinfo, port) = match self.authority() {
Some(a) => (a.userinfo().map(UserInfo::as_str), a.port_u16()),
None => (None, None),
};
self.with_authority(userinfo, &host, port)
.map(|url| *self = url)
}
pub fn set_port(&mut self, port: Option<u16>) -> Result<(), InvalidUrl> {
let (userinfo, host, _) = self.host_parts()?;
self.with_authority(userinfo, host, port)
.map(|url| *self = url)
}
pub fn set_path(&mut self, path: &str) {
let prefixed;
let path = if self.auth_start != 0 && !path.is_empty() && !path.starts_with('/') {
prefixed = format!("/{path}");
&prefixed
} else {
path
};
let path = normalize_path(path);
*self = self.derive(|c| c.path = &path);
}
pub fn set_file_name(&mut self, name: &str) -> Result<(), InvalidUrl> {
if name.contains('/') || name == "." || name == ".." {
return Err(InvalidUrl::new(ErrorKind::InvalidPath));
}
self.with_file_name("e_cow(name, Component::Path, false))
.map(|url| *self = url)
}
fn with_file_name(&self, name: &str) -> Result<Url, InvalidUrl> {
let path = format!("{}{name}", dir(self.path().as_str()));
self.rebuild(|c| c.path = &path)
}
pub fn set_extension(&mut self, extension: &str) -> Result<(), InvalidUrl> {
let stem = self
.path()
.file_stem()
.ok_or(InvalidUrl::new(ErrorKind::InvalidPath))?;
if extension.contains('/') {
return Err(InvalidUrl::new(ErrorKind::InvalidPath));
}
let name = if extension.is_empty() {
Cow::Borrowed(stem)
} else {
let extension = quote_cow(extension, Component::Path, false);
Cow::Owned(format!("{stem}.{extension}"))
};
self.with_file_name(&name).map(|url| *self = url)
}
pub fn set_query(&mut self, query: Option<&str>) {
let query = query.map(|q| quote_cow(q, Component::Query, true));
*self = self.derive(|c| c.query = query.as_deref());
}
fn edit_query_pairs<I, K, V>(&mut self, keep: impl Fn(&str) -> bool, pairs: I)
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<str>,
V: AsRef<str>,
{
let existing = self.query().map_or("", Query::as_str);
let pieces: Vec<Cow<'_, str>> = query::pieces(existing)
.filter(|piece| keep(&unquote_cow(split_pair(piece).0, Component::QueryPart)))
.map(Cow::Borrowed)
.chain(pairs.into_iter().map(|(k, v)| {
let quote = |s: &str| quote_cow(s, Component::QueryPart, false).into_owned();
Cow::Owned(format!("{}={}", quote(k.as_ref()), quote(v.as_ref())))
}))
.collect();
let query = pieces.join("&");
*self = self.derive(|c| c.query = (!query.is_empty()).then_some(query.as_str()));
}
pub fn set_query_pairs<I, K, V>(&mut self, pairs: I)
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<str>,
V: AsRef<str>,
{
self.edit_query_pairs(|_| false, pairs);
}
pub fn extend_query_pairs<I, K, V>(&mut self, pairs: I)
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<str>,
V: AsRef<str>,
{
self.edit_query_pairs(|_| true, pairs);
}
pub fn update_query_pairs<I, K, V>(&mut self, pairs: I)
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<str>,
V: AsRef<str>,
{
let pairs: Vec<(K, V)> = pairs.into_iter().collect();
let keep = |key: &str| !pairs.iter().any(|(k, _)| k.as_ref() == key);
self.edit_query_pairs(keep, pairs.iter().map(|(k, v)| (k.as_ref(), v.as_ref())));
}
pub fn remove_query_params<I, K>(&mut self, keys: I)
where
I: IntoIterator<Item = K>,
K: AsRef<str>,
{
let keys: Vec<K> = keys.into_iter().collect();
let keep = |key: &str| !keys.iter().any(|k| k.as_ref() == key);
self.edit_query_pairs(keep, std::iter::empty::<(&str, &str)>());
}
pub fn set_fragment(&mut self, fragment: Option<&str>) {
let fragment = fragment.map(|f| quote_cow(f, Component::Fragment, true));
*self = self.derive(|c| c.fragment = fragment.as_deref());
}
pub fn into_parts(self) -> crate::Parts {
let slice = |start: u16, end: usize| self.data.slice(start as usize..end);
crate::Parts {
scheme: self.scheme().map(|_| slice(0, self.scheme_end as usize)),
authority: self
.authority()
.map(|_| slice(self.auth_start, self.path_start as usize)),
path_and_query: slice(self.path_start, self.query_end as usize),
fragment: self
.fragment()
.map(|_| slice(self.query_end + 1, self.data.len())),
}
}
pub fn into_byte_string(self) -> ByteString {
self.data
}
}
fn dir(path: &str) -> &str {
path.rfind('/').map_or("", |i| &path[..=i])
}
str_fmt!(Url);
str_eq!(Url);
impl FromStr for Url {
type Err = InvalidUrl;
fn from_str(s: &str) -> Result<Url, InvalidUrl> {
parse::parse(s, None)
}
}
macro_rules! try_from {
($($ty:ty => |$s:ident| $conv:expr;)*) => {$(
impl TryFrom<$ty> for Url {
type Error = InvalidUrl;
fn try_from($s: $ty) -> Result<Url, InvalidUrl> {
$conv
}
}
)*};
}
try_from! {
&str => |s| parse::parse(s, None);
&String => |s| parse::parse(s, None);
String => |s| Url::try_from(ByteString::from(s));
ByteString => |s| parse::parse(&s, Some(&s));
&ByteString => |s| parse::parse(s, Some(s));
&[u8] => |s| parse::parse(from_utf8(s).map_err(utf8_error)?, None);
Bytes => |s| {
from_utf8(&s).map_err(utf8_error)?;
Url::try_from(unsafe { ByteString::from_bytes_unchecked(s) })
};
}
#[allow(clippy::needless_pass_by_value)]
fn utf8_error(e: Utf8Error) -> InvalidUrl {
InvalidUrl::at(ErrorKind::InvalidChar('\u{FFFD}'), e.valid_up_to())
}
impl From<Url> for ByteString {
fn from(url: Url) -> ByteString {
url.data
}
}
impl From<Url> for String {
fn from(url: Url) -> String {
url.as_str().to_string()
}
}
impl<S: AsRef<str>> Div<S> for &Url {
type Output = Url;
fn div(self, segment: S) -> Url {
self.push_segments([segment])
}
}
impl<S: AsRef<str>> Div<S> for Url {
type Output = Url;
fn div(self, segment: S) -> Url {
self.push_segments([segment])
}
}
#[cfg(feature = "http")]
mod http_impls {
use http::uri::{InvalidUri, Uri};
use super::Url;
use crate::error::InvalidUrl;
impl TryFrom<&Uri> for Url {
type Error = InvalidUrl;
fn try_from(uri: &Uri) -> Result<Url, InvalidUrl> {
Url::try_from(uri.to_string())
}
}
impl TryFrom<Uri> for Url {
type Error = InvalidUrl;
fn try_from(uri: Uri) -> Result<Url, InvalidUrl> {
Url::try_from(&uri)
}
}
impl TryFrom<&Url> for Uri {
type Error = InvalidUri;
fn try_from(url: &Url) -> Result<Uri, InvalidUri> {
Uri::try_from(&url.as_str()[..url.query_end as usize])
}
}
impl TryFrom<Url> for Uri {
type Error = InvalidUri;
fn try_from(url: Url) -> Result<Uri, InvalidUri> {
Uri::try_from(&url)
}
}
}
#[cfg(feature = "serde")]
mod serde_impls {
use std::fmt;
use serde::de::{self, Deserialize, Deserializer, Visitor};
use serde::{Serialize, Serializer};
use super::Url;
impl Serialize for Url {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
struct UrlVisitor;
impl Visitor<'_> for UrlVisitor {
type Value = Url;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("a url")
}
fn visit_str<E: de::Error>(self, v: &str) -> Result<Url, E> {
Url::try_from(v).map_err(E::custom)
}
fn visit_string<E: de::Error>(self, v: String) -> Result<Url, E> {
Url::try_from(v).map_err(E::custom)
}
}
impl<'de> Deserialize<'de> for Url {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Url, D::Error> {
deserializer.deserialize_str(UrlVisitor)
}
}
}