use super::{
KeyRule, RESERVED_NAME, RESERVED_PREFIX, Rules, SEGMENT_MAX, TemplateError, TemplateKind,
Token, dot_segment, tokens,
};
#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
pub enum TemplateRefusal {
#[error(transparent)]
Parse(#[from] TemplateError),
#[error("a literal part breaks {}", .0.name())]
Literal(KeyRule),
}
pub fn check_template(text: &str, kind: TemplateKind) -> Result<(), TemplateRefusal> {
literal(text, kind, Rules::Key)
}
pub fn check_member_template(text: &str, kind: TemplateKind) -> Result<(), TemplateRefusal> {
literal(text, kind, Rules::Member)
}
const HEAD: usize = RESERVED_NAME.len();
struct Segment {
literal: bool,
len: usize,
head: [u8; HEAD],
}
impl Segment {
const fn new() -> Self {
Self {
literal: true,
len: 0,
head: [0; HEAD],
}
}
fn push(&mut self, b: u8) {
if let Some(slot) = self.head.get_mut(self.len) {
*slot = b;
}
self.len += 1;
}
fn head(&self) -> &[u8] {
self.head.get(..self.len.min(HEAD)).unwrap_or_default()
}
fn rule(&self, first: bool, last: bool, which: Rules) -> Option<KeyRule> {
if !self.literal {
return None;
}
if self.len == 0 {
return Some(if first {
KeyRule::LeadingSlash
} else if last {
KeyRule::TrailingSlash
} else {
KeyRule::EmptySegment
});
}
if std::str::from_utf8(self.head()).is_ok_and(|s| self.len <= 2 && dot_segment(s)) {
return Some(KeyRule::DotSegment);
}
if self.len > SEGMENT_MAX {
return Some(KeyRule::SegmentTooLong);
}
if which == Rules::Key && self.head() == RESERVED_NAME.as_bytes() {
return Some(KeyRule::ReservedName);
}
None
}
}
fn literal(text: &str, kind: TemplateKind, which: Rules) -> Result<(), TemplateRefusal> {
if text.is_empty() {
return Err(TemplateError::Empty.into());
}
let mut worst: Option<KeyRule> = None;
let mut broke = |rule: Option<KeyRule>| {
if let Some(r) = rule {
worst = Some(worst.map_or(r, |w| w.min(r)));
}
};
let mut segment = Segment::new();
let mut first = true;
let mut lead = Segment::new();
let mut leading = true;
for token in tokens(text, kind) {
match token? {
Token::Var(_) => {
segment.literal = false;
leading = false;
}
Token::Lit(s) => {
for &b in s.as_bytes() {
if leading {
lead.push(b);
}
if b == b'/' {
broke(segment.rule(first, false, which));
segment = Segment::new();
first = false;
} else if segment.literal {
segment.push(b);
}
}
}
}
}
broke(segment.rule(first, true, which));
let prefix = RESERVED_PREFIX.as_bytes();
if which == Rules::Key && lead.head().starts_with(prefix) {
let whole = leading && lead.len == prefix.len();
if whole || lead.head().get(prefix.len()) == Some(&b'/') {
broke(Some(KeyRule::ReservedPrefix));
}
}
match worst {
Some(rule) => Err(TemplateRefusal::Literal(rule)),
None => Ok(()),
}
}