use dustnet_core::protocol::ProtocolError;
use dustnet_core::scanner::{Scanner, Token};
use dustnet_core::serialize::to_aml;
const INCLUDE_TAG: &str = "include";
const NAME_ATTR: &str = "name";
#[derive(Debug, Clone, Copy)]
pub struct IncludeRequest<'a> {
pub path: &'a str,
pub query: Option<&'a str>,
pub identity: Option<&'a str>,
}
pub trait IncludeResolver: Send + Sync {
fn resolve(&self, name: &str, request: &IncludeRequest<'_>) -> Option<Vec<Token>>;
}
fn include_name(attributes: &[dustnet_core::scanner::Attribute]) -> Option<&str> {
attributes
.iter()
.find(|attribute| attribute.name == NAME_ATTR)
.map(|attribute| match &attribute.value {
dustnet_core::scanner::AttributeValue::String(value)
| dustnet_core::scanner::AttributeValue::Ident(value) => value.as_str(),
dustnet_core::scanner::AttributeValue::Flag => "",
})
.filter(|name| !name.is_empty())
}
fn is_include(token: &Token) -> bool {
match token {
Token::OpenTag { name, .. } | Token::CloseTag { name } => name == INCLUDE_TAG,
_ => false,
}
}
pub fn resolve_page(
content: &str,
resolver: &dyn IncludeResolver,
request: &IncludeRequest<'_>,
) -> Result<String, ProtocolError> {
if !content.contains("[include") {
return Ok(content.to_string());
}
let mut scanner = Scanner::new(content.as_bytes())
.map_err(|_| ProtocolError::InvalidMessage("page is not scannable AML".into()))?;
let tokens = scanner
.scan_all()
.map_err(|_| ProtocolError::InvalidMessage("page is not scannable AML".into()))?;
let mut resolved: Vec<Token> = Vec::new();
for token in &tokens {
match token {
Token::OpenTag {
name, attributes, ..
} if name == INCLUDE_TAG => {
let Some(include) = include_name(attributes) else {
continue;
};
let Some(generated) = resolver.resolve(include, request) else {
continue;
};
if generated.iter().any(is_include) {
return Err(ProtocolError::InvalidMessage(
"resolver returned an [include]; resolution is a single pass".into(),
));
}
resolved.extend(generated);
}
Token::CloseTag { name } if name == INCLUDE_TAG => continue,
other => resolved.push(other.clone()),
}
}
to_aml(&resolved)
.map_err(|error| ProtocolError::InvalidMessage(format!("generated AML: {error}").into()))
}
#[cfg(test)]
mod tests {
use super::*;
use dustnet_core::scanner::{Attribute, AttributeValue};
struct Fixed(Vec<(&'static str, Vec<Token>)>);
impl IncludeResolver for Fixed {
fn resolve(&self, name: &str, _request: &IncludeRequest<'_>) -> Option<Vec<Token>> {
self.0
.iter()
.find(|(claimed, _)| *claimed == name)
.map(|(_, tokens)| tokens.clone())
}
}
fn text(body: &str) -> Vec<Token> {
vec![
Token::OpenTag {
name: "text".into(),
attributes: Vec::new(),
self_closing: false,
},
Token::Text(body.into()),
Token::CloseTag {
name: "text".into(),
},
]
}
fn request() -> IncludeRequest<'static> {
IncludeRequest {
path: "/index.aml",
query: None,
identity: None,
}
}
fn resolve(content: &str, resolver: &dyn IncludeResolver) -> String {
resolve_page(content, resolver, &request()).expect("resolution failed")
}
#[test]
fn substitutes_a_claimed_include() {
let resolver = Fixed(vec![("links", text("a story"))]);
let out = resolve(
r#"[page mode=document][include name="links" /][/page]"#,
&resolver,
);
assert!(out.contains("a story"), "{out}");
assert!(!out.contains("include"), "{out}");
}
#[test]
fn drops_an_unclaimed_include() {
let resolver = Fixed(Vec::new());
let out = resolve(
r#"[page mode=document][text]before[/text][include name="links" /][/page]"#,
&resolver,
);
assert!(out.contains("before"), "{out}");
assert!(!out.contains("include"), "{out}");
assert!(!out.contains("links"), "{out}");
}
#[test]
fn leaves_a_page_without_includes_untouched() {
let source = r#"[page mode=document][text fg=red]x[/text][/page]"#;
let out = resolve(source, &Fixed(Vec::new()));
assert_eq!(out, source);
}
#[test]
fn generated_user_text_cannot_become_markup() {
let hostile = r#"x" ][form action="/login"][input name="password" password /][/form]"#;
let resolver = Fixed(vec![("links", text(hostile))]);
let out = resolve(
r#"[page mode=document][include name="links" /][/page]"#,
&resolver,
);
let tokens = Scanner::new(out.as_bytes())
.expect("output is scannable")
.scan_all()
.expect("output scans");
assert!(
!tokens.iter().any(|token| matches!(
token,
Token::OpenTag { name, .. } if name == "form" || name == "input"
)),
"injected markup became elements: {out}"
);
assert!(tokens.iter().any(
|token| matches!(token, Token::Text(body) if body.contains(r#"[form action="/login"]"#))
));
}
#[test]
fn generated_attribute_values_cannot_close_their_quote() {
let hostile = r#"https://ok.example/" ][form action="/login"]"#;
let resolver = Fixed(vec![(
"links",
vec![Token::OpenTag {
name: "link".into(),
attributes: vec![Attribute {
name: "href".into(),
value: AttributeValue::String(hostile.into()),
}],
self_closing: true,
}],
)]);
let out = resolve(
r#"[page mode=document][include name="links" /][/page]"#,
&resolver,
);
let tokens = Scanner::new(out.as_bytes())
.expect("output is scannable")
.scan_all()
.expect("output scans");
assert!(
!tokens.iter().any(|token| matches!(
token,
Token::OpenTag { name, .. } if name == "form"
)),
"attribute escaped its quote: {out}"
);
}
#[test]
fn a_resolver_returning_an_include_is_refused() {
let resolver = Fixed(vec![(
"links",
vec![Token::OpenTag {
name: "include".into(),
attributes: vec![Attribute {
name: "name".into(),
value: AttributeValue::String("links".into()),
}],
self_closing: true,
}],
)]);
let error = resolve_page(
r#"[page mode=document][include name="links" /][/page]"#,
&resolver,
&request(),
)
.expect_err("expected refusal");
assert!(format!("{error}").contains("single pass"), "{error}");
}
#[test]
fn a_nameless_include_is_dropped() {
let out = resolve("[page mode=document][include /][/page]", &Fixed(Vec::new()));
assert!(!out.contains("include"), "{out}");
}
#[test]
fn resolves_every_placeholder_independently() {
let resolver = Fixed(vec![("account", text("log in")), ("links", text("story"))]);
let out = resolve(
r#"[page mode=document][include name="account" /][include name="links" /][/page]"#,
&resolver,
);
let account = out.find("log in").expect("account content missing");
let links = out.find("story").expect("links content missing");
assert!(account < links, "resolved out of source order: {out}");
}
#[test]
fn a_closing_include_tag_is_dropped_too() {
let resolver = Fixed(vec![("links", text("story"))]);
let out = resolve(
r#"[page mode=document][include name="links"][/include][/page]"#,
&resolver,
);
assert!(out.contains("story"), "{out}");
assert!(!out.contains("include"), "{out}");
}
}