//! Components of IRIs.
mod authority;
use core::num::NonZeroUsize;
use core::ops::{Range, RangeFrom, RangeTo};
use crate::parser::trusted as trusted_parser;
use crate::spec::Spec;
use crate::types::RiReferenceStr;
pub use self::authority::AuthorityComponents;
/// Positions to split an IRI into components.
#[derive(Debug, Clone, Copy)]
pub(crate) struct Splitter {
/// Scheme end.
scheme_end: Option<NonZeroUsize>,
/// Authority end.
///
/// Note that absence of the authority and the empty authority is
/// distinguished.
authority_end: Option<NonZeroUsize>,
/// Query start (after the leading `?`).
query_start: Option<NonZeroUsize>,
/// Fragment start (after the leading `#`).
fragment_start: Option<NonZeroUsize>,
}
impl Splitter {
/// Creates a new splitter.
#[inline]
#[must_use]
pub(crate) fn new(
scheme_end: Option<NonZeroUsize>,
authority_end: Option<NonZeroUsize>,
query_start: Option<NonZeroUsize>,
fragment_start: Option<NonZeroUsize>,
) -> Self {
Self {
scheme_end,
authority_end,
query_start,
fragment_start,
}
}
/// Decomposes an IRI into five major components: scheme, authority, path, query, and fragment.
#[must_use]
fn split_into_major(
self,
s: &str,
) -> (Option<&str>, Option<&str>, &str, Option<&str>, Option<&str>) {
let (scheme, next_of_scheme) = match self.scheme_end {
// +1: ":".len()
Some(end) => (Some(&s[..end.get()]), end.get() + 1),
None => (None, 0),
};
let (authority, next_of_authority) = match self.authority_end {
// +2: "//".len()
Some(end) => (Some(&s[(next_of_scheme + 2)..end.get()]), end.get()),
None => (None, next_of_scheme),
};
let (fragment, end_of_prev_of_fragment) = match self.fragment_start {
// -1: "#".len()
Some(start) => (Some(&s[start.get()..]), start.get() - 1),
None => (None, s.len()),
};
let (query, end_of_path) = match self.query_start {
Some(start) => (
Some(&s[start.get()..end_of_prev_of_fragment]),
// -1: "?".len()
start.get() - 1,
),
None => (None, end_of_prev_of_fragment),
};
let path = &s[next_of_authority..end_of_path];
(scheme, authority, path, query, fragment)
}
/// Returns the range for the scheme part.
#[inline]
#[must_use]
fn scheme_range(self) -> Option<RangeTo<usize>> {
self.scheme_end.map(|end| ..end.get())
}
/// Returns the scheme as a string.
#[inline]
#[must_use]
pub(crate) fn scheme_str<'a>(&self, s: &'a str) -> Option<&'a str> {
self.scheme_range().map(|range| &s[range])
}
/// Returns true if the IRI has a scheme part, false otherwise.
#[inline]
#[must_use]
pub(crate) fn has_scheme(&self) -> bool {
self.scheme_end.is_some()
}
/// Returns the range for the authority part.
#[inline]
#[must_use]
fn authority_range(self) -> Option<Range<usize>> {
let end = self.authority_end?.get();
// 2: "//".len()
// +3: "://".len()
let start = self.scheme_end.map_or(2, |v| v.get() + 3);
Some(start..end)
}
/// Returns the authority as a string.
#[inline]
#[must_use]
pub(crate) fn authority_str<'a>(&self, s: &'a str) -> Option<&'a str> {
self.authority_range().map(|range| &s[range])
}
/// Returns true if the IRI has an authority part, false otherwise.
#[inline]
#[must_use]
pub(crate) fn has_authority(&self) -> bool {
self.authority_end.is_some()
}
/// Returns the range for the path part.
#[inline]
#[must_use]
fn path_range(self, full_len: usize) -> Range<usize> {
// -1: "?".len() and "#".len()
let end = self
.query_start
.or(self.fragment_start)
.map_or(full_len, |v| v.get() - 1);
let start = self.authority_end.map_or_else(
// +1: ":".len()
|| self.scheme_end.map_or(0, |v| v.get() + 1),
NonZeroUsize::get,
);
start..end
}
/// Returns the path as a string.
#[inline]
#[must_use]
pub(crate) fn path_str<'a>(&self, s: &'a str) -> &'a str {
&s[self.path_range(s.len())]
}
/// Returns true if the path part of the IRI is empty.
#[inline]
#[must_use]
pub(crate) fn is_path_empty(&self, full_len: usize) -> bool {
self.path_range(full_len).is_empty()
}
/// Returns the range for the query part excluding a prefix `?`.
#[inline]
#[must_use]
fn query_range(self, full_len: usize) -> Option<Range<usize>> {
let start = self.query_start?.get();
// -1: "#".len()
let end = self.fragment_start.map_or(full_len, |v| v.get() - 1);
Some(start..end)
}
/// Returns the query as a string.
#[inline]
#[must_use]
pub(crate) fn query_str<'a>(&self, s: &'a str) -> Option<&'a str> {
self.query_range(s.len()).map(|range| &s[range])
}
/// Returns true if the IRI has a query part, false otherwise.
#[inline]
#[must_use]
pub(crate) fn has_query(&self) -> bool {
self.query_start.is_some()
}
/// Returns the range for the fragment part excluding a prefix `#`.
#[inline]
#[must_use]
pub(crate) fn fragment_range(self) -> Option<RangeFrom<usize>> {
self.fragment_start.map(|v| v.get()..)
}
/// Returns the fragment as a string.
#[inline]
#[must_use]
pub(crate) fn fragment_str<'a>(&self, s: &'a str) -> Option<&'a str> {
self.fragment_range().map(|range| &s[range])
}
}
/// Components of an IRI reference.
///
/// See <https://tools.ietf.org/html/rfc3986#section-5.2.2>.
#[derive(Debug, Clone, Copy)]
pub(crate) struct RiReferenceComponents<'a, S: Spec> {
/// Original complete string.
pub(crate) iri: &'a RiReferenceStr<S>,
/// Positions to split the IRI into components.
pub(crate) splitter: Splitter,
}
impl<'a, S: Spec> RiReferenceComponents<'a, S> {
/// Returns five major components: scheme, authority, path, query, and fragment.
#[inline]
#[must_use]
pub(crate) fn to_major(
self,
) -> (
Option<&'a str>,
Option<&'a str>,
&'a str,
Option<&'a str>,
Option<&'a str>,
) {
self.splitter.split_into_major(self.iri.as_str())
}
/// Returns the IRI reference.
#[inline]
#[must_use]
pub(crate) fn iri(&self) -> &'a RiReferenceStr<S> {
self.iri
}
/// Returns the scheme as a string.
#[inline]
#[must_use]
pub(crate) fn scheme_str(&self) -> Option<&str> {
self.splitter.scheme_str(self.iri.as_str())
}
/// Returns the authority as a string.
#[inline]
#[must_use]
pub(crate) fn authority_str(&self) -> Option<&str> {
self.splitter.authority_str(self.iri.as_str())
}
/// Returns the path as a string.
#[inline]
#[must_use]
pub(crate) fn path_str(&self) -> &str {
self.splitter.path_str(self.iri.as_str())
}
/// Returns the query as a string.
#[inline]
#[must_use]
pub(crate) fn query_str(&self) -> Option<&str> {
self.splitter.query_str(self.iri.as_str())
}
}
impl<'a, S: Spec> From<&'a RiReferenceStr<S>> for RiReferenceComponents<'a, S> {
#[inline]
fn from(s: &'a RiReferenceStr<S>) -> Self {
trusted_parser::decompose_iri_reference(s)
}
}
