use ntex_bytes::ByteString;
use crate::authority::Authority;
use crate::error::{ErrorKind, InvalidUrl, InvalidUrlParts};
use crate::{parse, path::PathAndQuery, query::Fragment, scheme::Scheme, url::Url};
#[derive(Debug, Default, Clone)]
pub struct Builder {
base: Option<Url>,
scheme: Option<String>,
authority: Option<String>,
host: Option<String>,
userinfo: Option<(String, Option<String>)>,
port: Option<u16>,
path: Option<String>,
query: Option<String>,
pairs: Vec<(String, String)>,
fragment: Option<String>,
}
impl Builder {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn scheme(mut self, scheme: &str) -> Self {
self.scheme = Some(scheme.to_string());
self
}
#[must_use]
pub fn authority(mut self, authority: &str) -> Self {
self.authority = Some(authority.to_string());
self
}
#[must_use]
pub fn host(mut self, host: &str) -> Self {
self.host = Some(host.to_string());
self
}
#[must_use]
pub fn userinfo(mut self, username: &str, password: Option<&str>) -> Self {
self.userinfo = Some((username.to_string(), password.map(str::to_string)));
self
}
#[must_use]
pub fn port(mut self, port: u16) -> Self {
self.port = Some(port);
self
}
#[must_use]
pub fn path(mut self, path: &str) -> Self {
self.path = Some(path.to_string());
self
}
#[must_use]
pub fn query(mut self, query: &str) -> Self {
self.query = Some(query.to_string());
self
}
#[must_use]
pub fn query_pair(mut self, key: &str, value: &str) -> Self {
self.pairs.push((key.to_string(), value.to_string()));
self
}
#[must_use]
pub fn query_pairs<I, K, V>(mut self, pairs: I) -> Self
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<str>,
V: AsRef<str>,
{
self.pairs.extend(
pairs
.into_iter()
.map(|(k, v)| (k.as_ref().to_string(), v.as_ref().to_string())),
);
self
}
#[must_use]
pub fn fragment(mut self, fragment: &str) -> Self {
self.fragment = Some(fragment.to_string());
self
}
pub fn build(self) -> Result<Url, InvalidUrl> {
let mut url = self.base.unwrap_or_else(Url::empty);
if let Some(scheme) = self.scheme {
url.set_scheme(&scheme)?;
}
if let Some(authority) = self.authority {
url.set_authority(Some(&authority))?;
}
if let Some(host) = self.host {
url.set_host(&host)?;
}
if let Some((user, password)) = self.userinfo {
url.set_userinfo(Some(&user), password.as_deref())?;
}
if self.port.is_some() {
url.set_port(self.port)?;
}
if let Some(path) = self.path {
url.try_set_path(&path)?;
}
if let Some(query) = self.query {
url.try_set_query(Some(&query))?;
}
if !self.pairs.is_empty() {
url.try_extend_query_pairs(self.pairs)?;
}
if let Some(fragment) = self.fragment {
url.try_set_fragment(Some(&fragment))?;
}
if url.as_str().is_empty() {
Err(InvalidUrl::new(ErrorKind::Empty))
} else {
Ok(url)
}
}
}
impl From<Url> for Builder {
fn from(url: Url) -> Self {
Builder {
base: Some(url),
..Default::default()
}
}
}
#[derive(Debug, Default, Clone)]
pub struct Parts {
pub scheme: Option<ByteString>,
pub authority: Option<ByteString>,
pub path_and_query: ByteString,
pub fragment: Option<ByteString>,
}
impl Url {
pub fn from_parts(parts: Parts) -> Result<Url, InvalidUrlParts> {
let invalid_path = || InvalidUrlParts::from(InvalidUrl::new(ErrorKind::InvalidPath));
let pq = PathAndQuery::new(&parts.path_and_query)?;
let path = pq.path().as_str();
if let Some(scheme) = &parts.scheme {
Scheme::new(scheme)?;
}
if let Some(authority) = &parts.authority {
Authority::new(authority)?;
if !path.is_empty() && !path.starts_with('/') {
return Err(invalid_path());
}
} else if parts.scheme.is_none() && path.split('/').next().unwrap_or("").contains(':') {
return Err(invalid_path());
}
if let Some(fragment) = &parts.fragment {
Fragment::new(fragment)?;
}
let mut s = String::new();
if let Some(scheme) = &parts.scheme {
s.push_str(scheme);
s.push(':');
}
if let Some(authority) = &parts.authority {
s.push_str("//");
s.push_str(authority);
} else if path.starts_with("//") {
s.push_str("/.");
}
s.push_str(&parts.path_and_query);
if let Some(fragment) = &parts.fragment {
s.push('#');
s.push_str(fragment);
}
if s.is_empty() {
return Err(InvalidUrl::new(ErrorKind::Empty).into());
}
Ok(parse::parse(&s, None)?)
}
}