randogoth/itsybitsy
1
0
Fork 0
Code Issues Pull requests Projects Releases 5 Packages Wiki Activity Actions

feat: serve rendered pages over http, spartan and nex

Browse source
This commit is contained in:
randogoth 2026-10-04 19:55:21 +03:00
parent 46f12b10da
commit 2f38b8b929
30 changed files with 2896 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

170
wap/src/xhtmlmp.rs Normal file
View file

@ -0,0 +1,170 @@
//! XHTML Mobile Profile markup, and the `text/html` body derived from it.
//!
//! One document serves both: a WAP 2.0 client needs well-formed XML with the
//! prolog and the Mobile Profile doctype, while a browser parsing the same bytes
//! as `text/html` tolerates the leading `<?xml ...?>` as a bogus comment but
//! logs a warning for it. So the HTML form is the same markup with that one line
//! removed.
use itsybitsy_core::ir::{Block, Doc, Inline};
use crate::escape;
/// The XML declaration, which only the XHTML-MP form carries.
const PROLOG: &str = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
const DOCTYPE: &str = "<!DOCTYPE html PUBLIC \"-//WAPFORUM//DTD XHTML Mobile 1.0//EN\" \
\"http://www.wapforum.org/DTD/xhtml-mobile10.dtd\">\n";
/// Build the whole document. `prolog` distinguishes the two media types.
pub fn document(doc: &Doc, title: &str, prolog: bool) -> String {
let mut out = String::new();
if prolog {
out.push_str(PROLOG);
}
out.push_str(DOCTYPE);
out.push_str("<html xmlns=\"http://www.w3.org/1999/xhtml\">\n");
out.push_str(&format!("<head><title>{}</title></head>\n", escape::text(title)));
out.push_str("<body>\n");
blocks(&doc.blocks, &mut out);
out.push_str("</body>\n</html>\n");
out
}
fn blocks(blocks: &[Block], out: &mut String) {
for block in blocks {
self_block(block, out);
}
}
fn self_block(block: &Block, out: &mut String) {
match block {
Block::Heading { level, inline } => {
let level = (*level).clamp(1, 6);
out.push_str(&format!("<h{level}>{}</h{level}>\n", inlines(inline)));
}
Block::Paragraph(inline) => out.push_str(&format!("<p>{}</p>\n", inlines(inline))),
Block::CodeBlock { lines, .. } => {
out.push_str("<pre>");
out.push_str(&escape::text(&lines.join("\n")));
out.push_str("</pre>\n");
}
Block::Art { alt, lines } => {
// The label is the only description a client that cannot show the
// art would have, so it is kept as the title attribute.
out.push_str(&format!("<pre title=\"{}\">", escape::attr(alt)));
out.push_str(&escape::text(&lines.join("\n")));
out.push_str("</pre>\n");
}
Block::BlockQuote(inner) => {
out.push_str("<blockquote>\n");
blocks(inner, out);
out.push_str("</blockquote>\n");
}
Block::List { ordered, start, items } => {
if *ordered {
// XHTML-MP has no `start` attribute, so a list beginning
// elsewhere than 1 cannot be expressed; the numbers restart.
out.push_str("<ol>\n");
} else {
out.push_str("<ul>\n");
}
let _ = start;
for item in items {
out.push_str("<li>");
// A single paragraph needs no block wrapper inside the item.
match item.as_slice() {
[Block::Paragraph(inline)] => out.push_str(&inlines(inline)),
blocks_in_item => {
out.push('\n');
blocks(blocks_in_item, out);
}
}
out.push_str("</li>\n");
}
out.push_str(if *ordered { "</ol>\n" } else { "</ul>\n" });
}
Block::Table { head, rows, .. } => {
out.push_str("<table>\n");
if !head.is_empty() {
out.push_str("<tr>");
for cell in head {
out.push_str(&format!("<th>{}</th>", inlines(cell)));
}
out.push_str("</tr>\n");
}
for row in rows {
out.push_str("<tr>");
for cell in row {
out.push_str(&format!("<td>{}</td>", inlines(cell)));
}
out.push_str("</tr>\n");
}
out.push_str("</table>\n");
}
Block::Rule => out.push_str("<hr/>\n"),
// Raw HTML is passed through: this is the one family of formats where it
// is already in the right language.
Block::Html(html) => {
out.push_str(html.trim_end());
out.push('\n');
}
// Alignment reaches only the fixed-width text formats. Pagination is a
// WML concern; a browser scrolls one document.
Block::Aligned { block, .. } => self_block(block, out),
Block::CardBreak { .. } => {}
}
}
fn inlines(inline: &[Inline]) -> String {
let mut out = String::new();
for item in inline {
match item {
Inline::Text(text) => out.push_str(&escape::text(text)),
Inline::Code(code) => out.push_str(&format!("<code>{}</code>", escape::text(code))),
Inline::Emph(inner) => out.push_str(&format!("<em>{}</em>", inlines(inner))),
Inline::Strong(inner) => out.push_str(&format!("<strong>{}</strong>", inlines(inner))),
// XHTML-MP 1.0 has no <del>, and <strike> is not in the profile, so
// the text survives without its markup rather than being dropped.
Inline::Strike(inner) => out.push_str(&inlines(inner)),
Inline::Link { href, title, label } => {
let title = title
.as_deref()
.map(|t| format!(" title=\"{}\"", escape::attr(t)))
.unwrap_or_default();
out.push_str(&format!(
"<a href=\"{}\"{title}>{}</a>",
escape::attr(href),
inlines(label)
));
}
Inline::Image { src, title, alt } => {
let title = title
.as_deref()
.map(|t| format!(" title=\"{}\"", escape::attr(t)))
.unwrap_or_default();
out.push_str(&format!(
"<img src=\"{}\" alt=\"{}\"{title}/>",
escape::attr(src),
escape::attr(&Doc::plain_text(alt))
));
}
Inline::SoftBreak => out.push('\n'),
Inline::HardBreak => out.push_str("<br/>\n"),
Inline::Html(html) => out.push_str(html),
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_prolog_is_present_only_when_asked_for() {
let doc = Doc { blocks: Vec::new(), first_h1: None };
assert!(document(&doc, "T", true).starts_with("<?xml"));
assert!(document(&doc, "T", false).starts_with("<!DOCTYPE html"));
}
}