use markdoc::IndexMap;
use markdoc::ast::Node;
use markdoc::ext::bundle::Bundle;
use markdoc::ext::partials::{PartialResolver, expand_partials, load_partials};
use markdoc::ext::variables::Bindings;
use markdoc::ext::{Frontmatter, ParseOptions, control_flow, functions};
use markdoc::schema::Config;
use markdoc::types::{
MarkdocError, RenderableTreeNode, Result, Scalar, ValidationError, ValidationLevel,
};
pub const OVERLAY: &str = include_str!("../schema/markdoc-pdf.overlay.toml");
pub fn bundle(overlays: &[&str]) -> std::result::Result<Bundle, (usize, String)> {
let mut bundle = Bundle::builtin();
bundle
.overlay(OVERLAY)
.expect("markdoc-pdf's own overlay loads");
for (i, text) in overlays.iter().enumerate() {
bundle.overlay(text).map_err(|e| (i, e.to_string()))?;
}
Ok(bundle)
}
pub fn parse_options(bundle: &Bundle) -> ParseOptions {
let mut options = bundle.render_options();
options.frontmatter = Frontmatter::Yaml;
options.args.spans = true;
options
}
pub fn parse(source: &str, options: &ParseOptions) -> Result<Node> {
markdoc::ext::parse(source, options)
}
pub fn expand(doc: &Node, resolver: &dyn PartialResolver, options: &ParseOptions) -> Result<Node> {
let partials = load_partials(doc, resolver, options)?;
if partials.is_empty() {
return Ok(doc.clone());
}
expand_partials(doc, &partials)
}
pub fn syntax_errors(doc: &Node, input: &str) -> Vec<String> {
std::iter::once(doc)
.chain(doc.walk())
.flat_map(|node| node.errors.iter().map(move |error| (node, error)))
.filter(|(_, error)| {
matches!(
error.level,
ValidationLevel::Error | ValidationLevel::Critical
)
})
.map(|(node, error)| {
let (file, line) = position(node, error);
let file = file.unwrap_or(input);
match line {
Some(line) => format!("{file}:{line}: {}", error.message),
None => format!("{file}: {}", error.message),
}
})
.collect()
}
fn position<'a>(node: &'a Node, error: &'a ValidationError) -> (Option<&'a str>, Option<usize>) {
let span = error.span.as_ref().or(node.span.as_ref());
match span {
Some(span) => (span.file.as_deref(), Some(span.start.line)),
None => (None, None),
}
}
pub fn config(
bundle: &Bundle,
frontmatter: Option<&Scalar>,
variables: &IndexMap<String, Scalar>,
) -> Config {
let mut config = Config::default();
config.functions.extend(functions::all());
bundle.apply(&mut config);
control_flow::apply_bundle(bundle, &mut config);
let mut bindings = Bindings::new();
if let Some(frontmatter) = frontmatter {
bindings = bindings.with_frontmatter(frontmatter);
}
bindings.with_all(variables).apply(&mut config);
config
}
pub fn unknown_functions(doc: &Node, config: &Config) -> Vec<String> {
let known = markdoc::merge_config(config).functions;
let has_code = |name: &str| {
known
.get(name)
.and_then(Option::as_ref)
.is_some_and(|f| f.transform.is_some())
};
let mut unknown: Vec<String> = Vec::new();
let mut stack: Vec<&Scalar> = std::iter::once(doc)
.chain(doc.walk())
.flat_map(|node| node.attributes.values())
.collect();
while let Some(value) = stack.pop() {
match value {
Scalar::Function(function) => {
if !has_code(&function.name) && !unknown.contains(&function.name) {
unknown.push(function.name.clone());
}
stack.extend(function.parameters.values());
}
Scalar::Array(items) => stack.extend(items),
Scalar::Object(members) => stack.extend(members.values()),
_ => {}
}
}
unknown
}
pub fn transform(doc: &Node, config: &Config) -> Result<RenderableTreeNode> {
markdoc::transform(doc, config)?
.to_render()
.map_err(MarkdocError::TransformError)
}
pub fn render_tree(source: &str) -> Result<RenderableTreeNode> {
let bundle = bundle(&[]).expect("no overlays to fail");
let doc = parse(source, &parse_options(&bundle).with_spans(false))?;
let config = config(&bundle, doc.attributes.get("frontmatter"), &IndexMap::new());
transform(&doc, &config)
}
#[cfg(test)]
mod tests {
use super::*;
use markdoc::ext::partials::InMemoryPartialResolver;
fn html_names(node: &RenderableTreeNode, out: &mut Vec<String>) {
if let RenderableTreeNode::Tag(t) = node {
out.push(t.name.clone());
for c in &t.children {
html_names(c, out);
}
}
}
#[test]
fn own_overlay_declares_what_only_this_renderer_reads() {
let tree = render_tree("{% toc /%}\n\nText{% footnote %}A note.{% /footnote %}\n").unwrap();
let mut names = Vec::new();
html_names(&tree, &mut names);
assert_eq!(names, ["article", "toc", "p", "footnote"]);
}
#[test]
fn parse_options_are_the_renderers() {
let options = parse_options(&bundle(&[]).unwrap());
assert!(options.tokenizer.allow_indentation);
assert!(options.tokenizer.allow_comments);
assert!(options.strip_bom);
assert_eq!(options.frontmatter, Frontmatter::Yaml);
assert!(options.args.spans && options.args.location);
assert_eq!(
options.tokenizer.markdown_it.get("typographer"),
Some(&serde_json::Value::Bool(true))
);
let corpus = "[parse]\nallow_comments = false\nfrontmatter = \"raw\"\n";
let options = parse_options(&bundle(&[corpus]).unwrap());
assert!(!options.tokenizer.allow_comments);
assert_eq!(options.frontmatter, Frontmatter::Yaml);
}
#[test]
fn a_corpus_files_validation_and_function_tables_reach_the_config() {
let markdoc_toml = "[parse]\nallow_indentation = true\n\n\
[validation]\nvalidate_functions = true\n\n\
[functions.higher]\ndescription = \"x\"\n\
[functions.higher.parameters.0]\ntype = [\"String\"]\n\
[functions.include]\ndescription = \"In the list\"\n";
let bundle = bundle(&[markdoc_toml]).unwrap();
assert_eq!(
bundle.function_names().collect::<Vec<_>>(),
["higher", "include"]
);
let config = config(&bundle, None, &IndexMap::new());
assert!(config.validation.validate_functions);
let include = config.functions["include"].as_ref().unwrap();
assert!(include.transform.is_some());
assert_eq!(include.description.as_deref(), Some("In the list"));
assert_eq!(bundle.functions_without_code(&config), ["higher"]);
assert_eq!(super::bundle(&["", "[tagz.x]\n"]).unwrap_err().0, 1);
}
#[test]
fn frontmatter_and_build_variables_are_bound() {
let bundle = bundle(&[]).unwrap();
let doc = parse(
"---\ntitle: Book\n---\n# {% $markdoc.frontmatter.title %} {% $v %}\n",
&parse_options(&bundle),
)
.unwrap();
let vars = IndexMap::from([("v".to_string(), Scalar::String("2".into()))]);
let config = config(&bundle, doc.attributes.get("frontmatter"), &vars);
let html =
markdoc::renderers::html::render(&markdoc::transform(&doc, &config).unwrap()).unwrap();
assert_eq!(html, "<article><h1>Book 2</h1></article>");
}
#[test]
fn partials_are_spliced_with_the_documents_options() {
let resolver = InMemoryPartialResolver::new()
.with(
"a.md",
"\u{FEFF}---\ntitle: dropped\n---\n# A\n\n{% partial file=\"b.md\" /%}\n",
)
.with("b.md", "<!-- hidden -->\nB\n");
let options = parse_options(&bundle(&[]).unwrap());
let doc = parse("{% partial file=\"a.md\" /%}\n", &options).unwrap();
let doc = expand(&doc, &resolver, &options).unwrap();
let kinds: Vec<&str> = doc.children.iter().map(|c| c.node_type.as_str()).collect();
assert_eq!(kinds, ["heading", "comment", "paragraph"]);
assert!(doc.attributes.get("frontmatter").is_none());
let cycle = InMemoryPartialResolver::new().with("a.md", "{% partial file=\"a.md\" /%}\n");
let err = expand(&doc_with("a.md", &options), &cycle, &options).unwrap_err();
assert!(err.to_string().contains("cycle"), "{err}");
}
#[test]
fn syntax_errors_are_reported_with_their_file_and_line() {
let resolver = InMemoryPartialResolver::new().with("p.md", "Text\n\n{% callout %}\nopen\n");
let options = parse_options(&bundle(&[]).unwrap());
let doc = parse("# Title\n\n{% partial file=\"p.md\" /%}\n", &options).unwrap();
let doc = expand(&doc, &resolver, &options).unwrap();
let errors = syntax_errors(&doc, "book.mdoc");
assert_eq!(errors.len(), 1, "{errors:?}");
assert!(errors[0].starts_with("p.md:3: "), "{errors:?}");
let clean = parse("# Fine\n", &options).unwrap();
assert!(syntax_errors(&clean, "x.mdoc").is_empty());
}
#[test]
fn functions_without_code_are_named() {
let bundle = bundle(&[]).unwrap();
let doc = parse(
"{% if higher($v, [\"1.4\"]) %}\nA {% upper(\"x\") %}\n{% /if %}\n\n\
{% if and(include($p, \"a\"), equals(lower(1), 2)) %}\nB\n{% /if %}\n",
&parse_options(&bundle),
)
.unwrap();
let config = config(&bundle, None, &IndexMap::new());
let mut names = unknown_functions(&doc, &config);
names.sort();
assert_eq!(names, ["higher", "lower", "upper"]);
}
fn doc_with(file: &str, options: &ParseOptions) -> Node {
parse(&format!("{{% partial file=\"{file}\" /%}}\n"), options).unwrap()
}
}