use std::any::Any;
use std::borrow::{Borrow, Cow};
use std::ops::{Add, AddAssign, Div};
use std::str::FromStr;
use ntex_bytes::{BufMut, ByteString, Bytes, BytesMut};
use simdutf8::compat::{Utf8Error, from_utf8};
use crate::authority::{self, Authority, Port, UserInfo};
use crate::error::{ErrorKind, InvalidUrl};
use crate::path::{Path, PathAndQuery};
use crate::query::{self, Fragment, Query, split_pair};
use crate::quoting::{Component, quote, requote, unquote};
use crate::{chars::lowercase, host::normalize_host, parse, scheme::Scheme};
#[derive(Clone)]
pub struct Url {
data: ByteString,
scheme_end: u16,
auth_start: u16,
path_start: u16,
path_end: u16,
query_end: u16,
host_start: u16,
host_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> {
assemble_inner(c, orig, false)
}
pub(crate) fn assemble_target(
c: &Components<'_>,
orig: Option<&ByteString>,
) -> Result<Url, InvalidUrl> {
assemble_inner(c, orig, true)
}
pub(crate) fn origin_form(data: ByteString, query: Option<Option<usize>>) -> Url {
debug_assert!(data.starts_with('/') && !data.starts_with("//"));
debug_assert!(data.len() <= parse::MAX_LEN);
let query = match query {
Some(None) => None,
Some(Some(i)) if data.as_bytes().get(i) == Some(&b'?') => Some(i),
_ => data.find('?'),
};
debug_assert_eq!(query, data.find('?'), "{data:?}");
let len = data.len() as u16;
let path_end = query.map_or(len, |i| i as u16);
Url {
data,
scheme_end: 0,
auth_start: 0,
path_start: 0,
path_end,
query_end: len,
host_start: 0,
host_end: 0,
}
}
fn assemble_inner(
c: &Components<'_>,
orig: Option<&ByteString>,
target: bool,
) -> Result<Url, InvalidUrl> {
let stripped;
let c = match c.authority {
Some(a) if !target => {
stripped = Components {
authority: Some(strip_default_port(c.scheme, a)),
..*c
};
&stripped
}
_ => c,
};
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('/') || target {
""
} 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 > parse::MAX_LEN {
return Err(InvalidUrl::new(ErrorKind::TooLong));
}
let reuse = orig.filter(|orig| {
orig.len() == len && {
let orig = orig.as_str().as_bytes();
let mut pos = 0;
pieces.iter().all(|p| {
let start = pos;
pos += p.len();
p.is_empty() || orig[start..pos] == *p.as_bytes()
})
}
});
let data = match reuse {
Some(orig) => orig.clone(),
None => concat(&pieces, len),
};
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 hidden = if prefix == "/." { lens[4] } else { 0 };
let path_start = lens[..4].iter().sum::<u16>() + hidden;
let path_end = lens[..6].iter().sum::<u16>();
let query_end = path_end + lens[6] + lens[7];
let (host_start, host_end) = match c.authority {
Some(a) => {
let host = authority::split(a).1;
let start = auth_start + authority::offset(a, host) as u16;
(start, start + host.len() as u16)
}
None => (0, 0),
};
Ok(Url {
data,
scheme_end,
auth_start,
path_start,
path_end,
query_end,
host_start,
host_end,
})
}
fn strip_default_port<'a>(scheme: Option<&str>, authority: &'a str) -> &'a str {
if !authority.as_bytes().last().is_some_and(u8::is_ascii_digit) {
return authority;
}
let Some(default) = scheme.and_then(|s| Scheme::from_str_unchecked(s).default_port()) else {
return authority;
};
let (_, host, port) = authority::split(authority);
if port.and_then(|p| authority::parse_port(p).ok()) == Some(default) {
&authority[..authority::offset(authority, host) + host.len()]
} else {
authority
}
}
fn concat(pieces: &[&str], len: usize) -> ByteString {
const INLINE: usize = 23;
let bytes = if len <= INLINE {
let mut buf = [0u8; INLINE];
let mut pos = 0;
for p in pieces {
buf[pos..pos + p.len()].copy_from_slice(p.as_bytes());
pos += p.len();
}
Bytes::copy_from_slice(&buf[..len])
} else {
let mut buf = BytesMut::with_capacity(len);
let dst = &mut buf.chunk_mut()[..len];
let mut pos = 0;
for p in pieces {
dst[pos..pos + p.len()].copy_from_slice(p.as_bytes());
pos += p.len();
}
assert_eq!(pos, len);
unsafe { buf.advance_mut(len) };
buf.freeze()
};
unsafe { ByteString::from_bytes_unchecked(bytes) }
}
fn too_long<T>(res: Result<T, InvalidUrl>) -> T {
match res {
Ok(v) => v,
Err(e) => panic!("{e}"),
}
}
impl Url {
pub const fn new() -> Url {
Url {
data: ByteString::from_static("/"),
scheme_end: 0,
auth_start: 0,
path_start: 0,
path_end: 1,
query_end: 1,
host_start: 0,
host_end: 0,
}
}
pub fn parse<T: AsRef<str>>(src: T) -> Result<Url, InvalidUrl> {
parse::parse_authority(src.as_ref())
}
pub fn parse_ref<T: AsRef<str>>(src: T) -> Result<Url, InvalidUrl> {
parse::parse(src.as_ref(), None)
}
pub fn parse_target(src: impl Into<Bytes>) -> Result<Url, InvalidUrl> {
parse::parse_target(src.into())
}
pub fn parse_target_str(
src: impl Into<ByteString>,
query: Option<usize>,
) -> Result<Url, InvalidUrl> {
parse::parse_target_str(src.into(), Some(query))
}
pub fn from_target_parts(
scheme: Option<&str>,
authority: Option<&str>,
path_and_query: &str,
) -> Result<Url, InvalidUrl> {
if scheme == Some("") {
return Err(InvalidUrl::new(ErrorKind::InvalidScheme));
}
let (path, query) = crate::chars::split_at_char(path_and_query, b'?');
assemble_target(
&Components {
scheme,
authority,
path,
query,
fragment: None,
},
None,
)
}
pub fn validate_target(&self) -> Result<(), InvalidUrl> {
parse::validate_target(self)
}
pub fn normalize(&mut self) -> Result<(), InvalidUrl> {
let url = parse::normalize(&self.components(), Some(&self.data))?;
*self = url;
Ok(())
}
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<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,
host_start: 0,
host_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.host_start > self.auth_start)
.then(|| UserInfo::from_str_unchecked(self.range(self.auth_start, self.host_start - 1)))
}
pub fn username(&self) -> Option<Cow<'_, str>> {
self.userinfo().map(UserInfo::decoded_username)
}
pub fn password(&self) -> Option<Cow<'_, str>> {
self.userinfo()?.decoded_password()
}
pub fn host(&self) -> Option<&str> {
(self.host_end > self.host_start).then(|| self.range(self.host_start, self.host_end))
}
pub fn host_parsed(&self) -> Option<crate::Host<'_>> {
self.host().map(crate::Host::classify)
}
pub fn port(&self) -> Option<Port<&str>> {
if self.auth_start > 0 && self.host_end < self.path_start {
Port::parse(self.range(self.host_end + 1, self.path_start))
} else {
None
}
}
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 rel = String::from("/");
let mut pushed = false;
for segment in segments {
let segment = segment.as_ref();
let segment = segment.strip_prefix('/').unwrap_or(segment);
if !rel.ends_with('/') {
rel.push('/');
}
rel.push_str("e(segment, Component::Path));
pushed = true;
}
if !pushed {
return self.with_path(self.path().as_str());
}
if parse::has_dot_segments(&rel) {
rel = parse::remove_dot_segments(&rel);
}
let mut path = self.path().as_str().to_string();
if !path.is_empty() && !path.ends_with('/') {
path.push('/');
}
path.push_str(&rel[1..]);
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_ref(reference)?))
}
pub fn join_url(&self, r: &Url) -> Url {
let base = self.components();
let r = r.components();
let resolved = |path| Cow::Owned(parse::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(parse::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 = parse::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(user.unwrap_or(""), Component::UserInfo)),
(user, Some(password)) => Some(Cow::Owned(format!(
"{}:{}",
quote(user.unwrap_or(""), Component::UserInfo),
quote(password, Component::UserInfo)
))),
};
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) {
too_long(self.try_set_path(path));
}
pub(crate) fn try_set_path(&mut self, path: &str) -> Result<(), InvalidUrl> {
let prefixed;
let path = if self.auth_start != 0 && !path.is_empty() && !path.starts_with('/') {
prefixed = format!("/{path}");
&prefixed
} else {
path
};
let path = parse::normalize_path(path);
self.rebuild(|c| c.path = &path).map(|url| *self = url)
}
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(name, Component::Path))
.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(extension, Component::Path);
Cow::Owned(format!("{stem}.{extension}"))
};
self.with_file_name(&name).map(|url| *self = url)
}
pub fn set_query(&mut self, query: Option<&str>) {
too_long(self.try_set_query(query));
}
pub(crate) fn try_set_query(&mut self, query: Option<&str>) -> Result<(), InvalidUrl> {
let query = query.map(|q| requote(q, Component::Query));
self.rebuild(|c| c.query = query.as_deref())
.map(|url| *self = url)
}
fn edit_query_pairs<I, K, V>(
&mut self,
keep: impl Fn(&str) -> bool,
pairs: I,
) -> Result<(), InvalidUrl>
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(split_pair(piece).0, Component::QueryPart)))
.map(Cow::Borrowed)
.chain(pairs.into_iter().map(|(k, v)| {
let (k, v) = (k.as_ref(), v.as_ref());
let (k, v) = (
quote(k, Component::QueryPart),
quote(v, Component::QueryPart),
);
Cow::Owned(format!("{k}={v}"))
}))
.collect();
let query = pieces.join("&");
self.rebuild(|c| c.query = (!query.is_empty()).then_some(query.as_str()))
.map(|url| *self = url)
}
pub fn set_query_pairs<I, K, V>(&mut self, pairs: I)
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<str>,
V: AsRef<str>,
{
too_long(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>,
{
too_long(self.try_extend_query_pairs(pairs));
}
pub(crate) fn try_extend_query_pairs<I, K, V>(&mut self, pairs: I) -> Result<(), InvalidUrl>
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);
too_long(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);
too_long(self.edit_query_pairs(keep, std::iter::empty::<(&str, &str)>()));
}
pub fn set_fragment(&mut self, fragment: Option<&str>) {
too_long(self.try_set_fragment(fragment));
}
pub(crate) fn try_set_fragment(&mut self, fragment: Option<&str>) -> Result<(), InvalidUrl> {
let fragment = fragment.map(|f| requote(f, Component::Fragment));
self.rebuild(|c| c.fragment = fragment.as_deref())
.map(|url| *self = url)
}
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 Default for Url {
fn default() -> Url {
Url::new()
}
}
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| parse::parse(&s, None);
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)]
pub(crate) 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])
}
}
impl<U: Borrow<Url>> Add<U> for &Url {
type Output = Url;
fn add(self, reference: U) -> Url {
self.join_url(reference.borrow())
}
}
impl<U: Borrow<Url>> Add<U> for Url {
type Output = Url;
fn add(self, reference: U) -> Url {
self.join_url(reference.borrow())
}
}
impl<U: Borrow<Url>> AddAssign<U> for Url {
fn add_assign(&mut self, reference: U) {
*self = self.join_url(reference.borrow());
}
}
#[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> {
if uri.scheme().is_none()
&& let Some(authority) = uri.authority()
{
return Url::parse(authority.as_str());
}
let uri = uri.to_string();
if uri.starts_with("//") {
Url::try_from(format!("/.{uri}"))
} else {
Url::try_from(uri)
}
}
}
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> {
let start = match (url.scheme_end, url.auth_start) {
(0, 0) => url.path_start,
(0, auth_start) => auth_start,
_ => 0,
};
Uri::try_from(url.range(start, url.query_end))
}
}
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)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default() {
const URL: Url = Url::new();
assert_eq!(URL, Url::default());
let (url, p) = (Url::default(), Url::from_static("/"));
assert_eq!(url.scheme_end, p.scheme_end);
assert_eq!(url.auth_start, p.auth_start);
assert_eq!(url.path_start, p.path_start);
assert_eq!(url.path_end, p.path_end);
assert_eq!(url.query_end, p.query_end);
assert_eq!((url.host_start, url.host_end), (p.host_start, p.host_end));
assert_eq!(url, "/");
assert_eq!(url.path(), "/");
assert!(url.query().is_none());
assert!(!url.is_absolute());
}
#[test]
fn cached_host() {
let cases = [
(
"http://u:p@[::1]:8080/a",
Some("u:p"),
Some("[::1]"),
Some(8080),
),
("http://@h/", Some(""), Some("h"), None),
("http://h:0/", None, Some("h"), Some(0)),
("file:///etc", None, None, None),
("//h", None, Some("h"), None),
("/a", None, None, None),
];
for (src, userinfo, host, port) in cases {
let url = Url::from_static(src);
let auth = url.authority();
assert_eq!(url.userinfo().map(UserInfo::as_str), userinfo, "{src}");
assert_eq!(url.host(), host, "{src}");
assert_eq!(url.port_u16(), port, "{src}");
assert_eq!(
auth.and_then(|a| a.userinfo()).map(UserInfo::as_str),
userinfo
);
assert_eq!(auth.map(Authority::host).filter(|h| !h.is_empty()), host);
assert_eq!(auth.and_then(Authority::port_u16), port);
let mut copy = url.clone();
copy.set_path("/x");
assert_eq!((copy.host(), copy.port_u16()), (host, port), "{src}");
}
}
#[test]
fn double_slash_path() {
let url = Url::from_static("/.//a/../b?q#f");
assert_eq!(url, "/.//b?q#f");
assert_eq!(url.path(), "//b");
assert_eq!(url.path_and_query(), "//b?q");
assert!(url.authority().is_none());
assert_eq!(Url::from_parts(url.clone().into_parts()).unwrap(), url);
assert_eq!(url.join("c").unwrap().path(), "//c");
let mut url = Url::default();
url.set_path("//p");
assert_eq!(url, "/.//p");
assert_eq!(url.path(), "//p");
let mut url = Url::from_static("http://h//p?q");
assert_eq!(url.path(), "//p");
url.set_authority(None).unwrap();
assert_eq!(url, "http:/.//p?q");
assert_eq!(url.path(), "//p");
url.set_authority(Some("h")).unwrap();
assert_eq!(url, "http://h//p?q");
let parts = crate::Parts {
path_and_query: "//p?q".into(),
..crate::Parts::default()
};
assert_eq!(Url::from_parts(parts).unwrap().path(), "//p");
}
}