Struct rstml::ParserConfig

pub struct ParserConfig<C = Infallible> { /* private fields */ }

Configures the Parser behavior

Implementations

impl ParserConfig

pub fn new() -> ParserConfig

Create new ParserConfig with default config

impl<C> ParserConfig<C>

pub fn flat_tree(self) -> Self

Return flat tree instead of nested tree

pub fn number_of_top_level_nodes(self, number: usize) -> Self

Exact number of required top level nodes

pub fn type_of_top_level_nodes(self, node_type: NodeType) -> Self

Enforce the NodeType of top level nodes

pub fn recover_block(self, recover_block: bool) -> Self

Try to parse invalid syn::Block. If set tot true, NodeBlock can return Invalid variant.

If NodeBlock is failed to parse as syn::Block it still usefull to emit it as expression. It will enhance IDE compatibility, and provide completion in cases of invalid blocks, for example {x.} is invalid expression, because after dot token } is unexpected. But for ide it is a marker that quick completion should be provided.

pub fn always_self_closed_elements( self, elements: HashSet<&'static str>, ) -> Self

Set array of nodes that is known to be self closed, it also known as void element. Void elements has no child and must not have closing tag. Parser will not search for it closing tag, even if no slash at end of it open part was found.

Because we work in proc-macro context, we expect it as ’static refs.

Examples:

pub fn raw_text_elements(self, elements: HashSet<&'static str>) -> Self

Set array of nodes that is known to be parsed in two-phases, Parser will skip parsing of children nodes. and provide one child with RawText instead.

This is usefull when parsing <script> or <style> tags elements.

If you need fragment to be used in this context, empty string(“”) should be inserted.

Raw texts has few limitations, check out RawText documentation.

pub fn transform_block<F>(self, callback: F) -> Self

where F: Fn(ParseStream<'_>) -> Result<Option<TokenStream>> + 'static,

Transforms the value of all NodeType::Blocks with the given closure callback. The provided ParseStream is the content of the block.

When Some(TokenStream) is returned, the TokenStream is parsed as Rust block content. The ParseStream must be completely consumed in this case, meaning no tokens can be left in the stream.

If None is returned, parsing happens with the original ParseStream, since the tokens that are passend into the transform callback are a fork, which gets only advanced if Some is returned.

An example usage might be a custom syntax inside blocks which isn’t valid Rust. The given example simply translates the % character into the string percent

use quote::quote;
use syn::Token;
use rstml::{parse2_with_config, ParserConfig};

let tokens = quote! {
    <div>{%}</div>
};

let config = ParserConfig::new().transform_block(|input| {
    input.parse::<Token![%]>()?;
    Ok(Some(quote! { "percent" }))
});

parse2_with_config(tokens, config).unwrap();

pub fn element_close_wildcard<F>(self, predicate: F) -> Self

where F: Fn(&OpenTag, &CloseTag) -> bool + 'static,

Allows unmatched tag pairs where close tag matches a specified wildcard.

For example:

use quote::quote;
use rstml::{
    node::{Node, NodeElement},
    Parser, ParserConfig,
};
use syn::{Expr, ExprRange, RangeLimits, Stmt};

let config = ParserConfig::new()
    .element_close_wildcard(|_open_tag, close_tag| close_tag.name.is_wildcard());

let tokens = quote! {
    <{"OpenTag"}>{"Content"}</_>
};

Parser::new(config).parse_simple(tokens).unwrap();

pub fn element_close_use_default_wildcard_ident( self, open_tag_should_be_block: bool, ) -> Self

Allows unmatched tag pairs where close tag matches a specified wildcard.

Uses default wildcard ident (_), and optionally check whenewer open_tag name is block.

pub fn custom_node<CN: CustomNode>(self) -> ParserConfig<CN>

Enables parsing for [Node::Custom] using a type implementing CustomNode.

Trait Implementations

impl<C> Clone for ParserConfig<C>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C> Debug for ParserConfig<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ParserConfig

fn default() -> Self

Returns the “default value” for a type.

impl<C: CustomNode> From<ParserConfig<C>> for RecoveryConfig

fn from(config: ParserConfig<C>) -> Self

Converts to this type from the input type.