use std::sync::Arc;
use unityrs_core::limits::{Charge, Meter, heap_cost};
use super::classify::Class;
use super::table::{self, Set};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TemplateKind {
Texture,
Sprite,
AtlasSprite,
AtlasJson,
Glb,
}
impl TemplateKind {
#[must_use]
pub fn name(self) -> &'static str {
match self {
Self::Texture => "texture",
Self::Sprite => "sprite",
Self::AtlasSprite => "atlas_sprite",
Self::AtlasJson => "atlas_json",
Self::Glb => "glb",
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Var {
Input,
SafeInput,
Type,
Name,
SafeName,
PathId,
Atlas,
SafeAtlas,
Sprite,
SafeSprite,
ContainerPath,
SafeContainerPath,
}
impl Var {
#[must_use]
pub fn plain(self) -> Option<Self> {
Some(match self {
Self::SafeInput => Self::Input,
Self::SafeName => Self::Name,
Self::SafeAtlas => Self::Atlas,
Self::SafeSprite => Self::Sprite,
Self::SafeContainerPath => Self::ContainerPath,
_ => return None,
})
}
fn parse(name: &str) -> Option<Self> {
Some(match name {
"input" => Self::Input,
"safe_input" => Self::SafeInput,
"type" => Self::Type,
"name" => Self::Name,
"safe_name" => Self::SafeName,
"path_id" => Self::PathId,
"atlas" => Self::Atlas,
"safe_atlas" => Self::SafeAtlas,
"sprite" => Self::Sprite,
"safe_sprite" => Self::SafeSprite,
"container_path" => Self::ContainerPath,
"safe_container_path" => Self::SafeContainerPath,
_ => return None,
})
}
#[must_use]
pub fn allowed(self, kind: TemplateKind) -> bool {
match self {
Self::Input | Self::SafeInput | Self::PathId => true,
Self::Type | Self::Name | Self::SafeName => {
matches!(
kind,
TemplateKind::Texture | TemplateKind::Sprite | TemplateKind::Glb
)
}
Self::Atlas | Self::SafeAtlas => {
matches!(kind, TemplateKind::AtlasSprite | TemplateKind::AtlasJson)
}
Self::Sprite | Self::SafeSprite => kind == TemplateKind::AtlasSprite,
Self::ContainerPath | Self::SafeContainerPath => kind == TemplateKind::Glb,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
enum Piece {
Lit(String),
Var(Var),
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Template {
pieces: Vec<Piece>,
}
#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
pub enum TemplateError {
#[error("an empty template")]
Empty,
#[error("an unmatched brace at byte {0}")]
Brace(usize),
#[error("unknown variable {0:?}")]
Unknown(String),
#[error("variable {0:?} is not allowed here")]
NotAllowed(String),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Token<'t> {
Lit(&'t str),
Var(Var),
}
#[must_use]
pub fn tokens(text: &str, kind: TemplateKind) -> Tokens<'_> {
Tokens {
text,
kind,
at: 0,
done: false,
}
}
#[derive(Clone, Debug)]
pub struct Tokens<'t> {
text: &'t str,
kind: TemplateKind,
at: usize,
done: bool,
}
impl<'t> Iterator for Tokens<'t> {
type Item = Result<Token<'t>, TemplateError>;
fn next(&mut self) -> Option<Self::Item> {
let at = self.at;
let rest = self.text.get(at..).unwrap_or_default();
if self.done || rest.is_empty() {
return None;
}
let token = if rest.starts_with("{{") || rest.starts_with("}}") {
self.at += 2;
Ok(Token::Lit(rest.get(..1).unwrap_or_default()))
} else if let Some(after) = rest.strip_prefix('{') {
match after.find('}') {
None => Err(TemplateError::Brace(at)),
Some(end) => {
let name = after.get(..end).unwrap_or_default();
self.at += end + 2;
match Var::parse(name) {
None => Err(TemplateError::Unknown(name.to_owned())),
Some(var) if !var.allowed(self.kind) => {
Err(TemplateError::NotAllowed(name.to_owned()))
}
Some(var) => Ok(Token::Var(var)),
}
}
}
} else if rest.starts_with('}') {
Err(TemplateError::Brace(at))
} else {
let end = rest.find(['{', '}']).unwrap_or(rest.len());
self.at += end;
Ok(Token::Lit(rest.get(..end).unwrap_or_default()))
};
self.done = token.is_err();
Some(token)
}
}
impl Template {
#[cfg(feature = "gltf")]
pub(super) fn uses(&self, var: Var) -> bool {
self.pieces.iter().any(|piece| match piece {
Piece::Var(v) => *v == var || v.plain() == Some(var),
Piece::Lit(_) => false,
})
}
pub fn parse(text: &str, kind: TemplateKind) -> Result<Self, TemplateError> {
if text.is_empty() {
return Err(TemplateError::Empty);
}
let mut pieces = Vec::new();
let mut lit = String::new();
for token in tokens(text, kind) {
match token? {
Token::Lit(s) => lit.push_str(s),
Token::Var(var) => {
if !lit.is_empty() {
pieces.push(Piece::Lit(std::mem::take(&mut lit)));
}
pieces.push(Piece::Var(var));
}
}
}
if !lit.is_empty() {
pieces.push(Piece::Lit(lit));
}
Ok(Self { pieces })
}
pub fn expand<'v>(&self, value: impl Fn(Var) -> &'v [u8], out: &mut Vec<u8>) -> usize {
out.clear();
for (k, p) in self.pieces.iter().enumerate() {
let room = STOP.saturating_sub(out.len());
if room == 0 {
return self.tail(out, &[], k, &value);
}
let src = match p {
Piece::Lit(s) => s.as_bytes(),
Piece::Var(v) => match v.plain() {
Some(plain) => {
safe_into(value(plain), room, out);
continue;
}
None => value(*v),
},
};
out.extend(src.iter().take(room));
if src.len() > room {
let rest = src.get(room..).unwrap_or_default();
return self.tail(out, rest, k + 1, &value);
}
}
0
}
fn tail<'v>(
&self,
out: &[u8],
rest: &[u8],
next: usize,
value: &impl Fn(Var) -> &'v [u8],
) -> usize {
let head = out.get(out.len().saturating_sub(3)..).unwrap_or_default();
let later = self
.pieces
.get(next..)
.unwrap_or_default()
.iter()
.map_while(|p| match p {
Piece::Lit(s) => Some(s.as_bytes()),
Piece::Var(v) => v.plain().is_none().then(|| value(*v)),
})
.flatten();
let ahead = rest.iter().chain(later).take(3);
let mut window = [0u8; 6];
let mut len = 0;
for (slot, b) in window.iter_mut().zip(head.iter().chain(ahead)) {
*slot = *b;
len += 1;
}
cut_tail(window.get(..len).unwrap_or_default(), head.len())
}
}
#[must_use]
pub fn cut_tail(src: &[u8], at: usize) -> usize {
let head = src.get(..at).unwrap_or_default();
for back in 1..=head.len().min(3) {
let i = head.len() - back;
let Some(&b) = head.get(i) else {
return 0;
};
if b & 0xC0 == 0x80 {
continue;
}
let width = match b {
0xC2..=0xDF => 2,
0xE0..=0xEF => 3,
0xF0..=0xF4 => 4,
_ => 0,
};
let whole = src
.get(i..i + width)
.is_some_and(|c| std::str::from_utf8(c).is_ok());
return if width > back && whole { back } else { 0 };
}
0
}
pub fn safe_into(bytes: &[u8], room: usize, out: &mut Vec<u8>) {
let start = out.len();
let lead = bytes.iter().take_while(|b| **b == b'.').count();
let rest = bytes.get(lead..).unwrap_or_default();
if rest.is_empty() {
out.extend(b"unnamed".iter().take(room));
return;
}
let mut dots = 0usize;
let put = |c: u8, out: &mut Vec<u8>| {
if out.len() - start < room {
out.push(c);
true
} else {
false
}
};
for chunk in rest.utf8_chunks() {
let valid = chunk.valid().chars().map(Some);
let invalid = chunk.invalid().iter().map(|_| None);
for c in valid.chain(invalid) {
let mapped = match c {
Some('.') => {
dots += 1;
continue;
}
Some(c) if c.is_ascii_alphanumeric() || matches!(c, '_' | '-') => c as u8,
_ => b'_',
};
for _ in 0..std::mem::take(&mut dots) {
if !put(b'.', out) {
return;
}
}
if !put(mapped, out) {
return;
}
}
}
}
#[must_use]
pub fn safe(bytes: &[u8]) -> String {
let mut out = Vec::new();
safe_into(bytes, usize::MAX, &mut out);
String::from_utf8(out).unwrap_or_default()
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum KeyRule {
Empty,
NotUtf8,
ControlChar,
LeadingSlash,
TrailingSlash,
EmptySegment,
DotSegment,
SegmentTooLong,
TooLong,
ReservedPrefix,
ReservedName,
}
impl KeyRule {
#[must_use]
pub fn name(self) -> &'static str {
match self {
Self::Empty => "empty",
Self::NotUtf8 => "not_utf8",
Self::ControlChar => "control_char",
Self::LeadingSlash => "leading_slash",
Self::TrailingSlash => "trailing_slash",
Self::EmptySegment => "empty_segment",
Self::DotSegment => "dot_segment",
Self::SegmentTooLong => "segment_too_long",
Self::TooLong => "too_long",
Self::ReservedPrefix => "reserved_prefix",
Self::ReservedName => "reserved_name",
}
}
}
pub const SEGMENT_MAX: usize = 255;
pub const KEY_MAX: usize = 1024;
pub const STOP: usize = KEY_MAX + 1;
pub const RESERVED_PREFIX: &str = "_unityrs";
pub const RESERVED_NAME: &str = ".unityrs-tmp-";
fn dot_segment(segment: &str) -> bool {
segment == "." || segment == ".."
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Rules {
Key,
Member,
}
pub fn check(key: &[u8]) -> Result<&str, KeyRule> {
rules(key, Rules::Key)
}
pub fn check_member(path: &[u8]) -> Result<&str, KeyRule> {
rules(path, Rules::Member)
}
pub fn check_prefixed<'k>(
key: &'k [u8],
prefix: &str,
scratch: &mut Vec<u8>,
) -> Result<&'k str, KeyRule> {
let checked = check(key)?;
if !prefix.is_empty() {
scratch.clear();
scratch.extend(prefix.as_bytes().iter().take(STOP));
let room = STOP.saturating_sub(scratch.len());
scratch.extend(key.iter().take(room));
check(scratch)?;
}
Ok(checked)
}
fn rules(key: &[u8], which: Rules) -> Result<&str, KeyRule> {
if key.is_empty() {
return Err(KeyRule::Empty);
}
let long = key.len() > KEY_MAX;
let read = key.get(..STOP).unwrap_or(key);
let text = match std::str::from_utf8(read) {
Ok(k) => k,
Err(e) if long && e.error_len().is_none() => read
.get(..e.valid_up_to())
.and_then(|v| std::str::from_utf8(v).ok())
.ok_or(KeyRule::NotUtf8)?,
Err(_) => return Err(KeyRule::NotUtf8),
};
if text.chars().any(|c| c < ' ' || c == '\u{7f}') {
return Err(KeyRule::ControlChar);
}
if text.starts_with('/') {
return Err(KeyRule::LeadingSlash);
}
if !long && text.ends_with('/') {
return Err(KeyRule::TrailingSlash);
}
if text.contains("//") {
return Err(KeyRule::EmptySegment);
}
let segments = text.split('/');
let settled = if long {
segments.clone().count().saturating_sub(1)
} else {
usize::MAX
};
if segments.take(settled).any(dot_segment) {
return Err(KeyRule::DotSegment);
}
if read.split(|b| *b == b'/').any(|s| s.len() > SEGMENT_MAX) {
return Err(KeyRule::SegmentTooLong);
}
if long {
return Err(KeyRule::TooLong);
}
if which == Rules::Key {
if text == RESERVED_PREFIX
|| text
.strip_prefix(RESERVED_PREFIX)
.is_some_and(|r| r.starts_with('/'))
{
return Err(KeyRule::ReservedPrefix);
}
if text.split('/').any(|s| s.starts_with(RESERVED_NAME)) {
return Err(KeyRule::ReservedName);
}
}
Ok(text)
}
#[must_use]
pub fn entry_cost(len: usize) -> u64 {
heap_cost(u64::try_from(len).unwrap_or(u64::MAX))
}
#[derive(Debug)]
pub struct KeyTable {
keys: Set<Box<str>>,
strings: Charge,
}
impl KeyTable {
#[must_use]
pub fn new(meter: &Arc<Meter>) -> Self {
Self {
keys: Set::new(meter),
strings: Charge::zero(meter),
}
}
#[must_use]
pub fn contains(&self, key: &str) -> bool {
self.keys.contains(key)
}
pub fn take(&mut self, key: &str) -> Result<bool, Class> {
if self.keys.contains(key) {
return Ok(false);
}
self.keys.reserve_one()?;
self.strings
.grow(entry_cost(key.len()))
.map_err(|e| table::refused(&e))?;
self.keys.insert(Box::from(key))
}
#[must_use]
pub fn len(&self) -> usize {
self.keys.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.keys.is_empty()
}
}
mod literal;
pub use literal::{TemplateRefusal, check_member_template, check_template};
#[cfg(test)]
mod tests;