Struct rstml::visitor::Walker

pub struct Walker<V, C = Infallible, CW = AnyWalker<C>>
where
    C: CustomNode,
    V: Visitor<C> + VisitMut,
    CW: CustomNodeWalker<Custom = C>,
{ /* private fields */ }

Wrapper for visitor that calls inner visitors. Inner visitor should implement Visitor trait and syn::visit_mut::VisitMut.

For regular usecases it is recommended to use visit_nodes, visit_nodes_with_custom or visit_attributes functions.

But if you need it can be used by calling visit_* methods directly.

Example:

use quote::quote;
use rstml::{
    node::{Node, NodeText},
    visitor::{Visitor, Walker},
    Infallible,
};
use syn::parse_quote;

struct TestVisitor;
impl<C> Visitor<C> for TestVisitor {
    fn visit_text_node(&mut self, node: &mut NodeText) -> bool {
        *node = parse_quote!("modified");
        true
    }
}
impl syn::visit_mut::VisitMut for TestVisitor {}

let mut visitor = Walker::new(TestVisitor);

let tokens = quote! {
    <div>
        <span>"Some raw text"</span>
        <span></span>"And text after span"
    </div>
};
let mut nodes = rstml::parse2(tokens).unwrap();
for node in &mut nodes {
    visitor.visit_node(node);
}
let result = quote! {
    #(#nodes)*
};
assert_eq!(
    result.to_string(),
    quote! {
        <div>
            <span>"modified"</span>
            <span></span>"modified"
        </div>
    }
    .to_string()
);

Implementations

impl<V, C> Walker<V, C>

where C: CustomNode, V: Visitor<C> + VisitMut,

pub fn new(visitor: V) -> Self

pub fn with_custom_handler<OtherCW>(visitor: V) -> Walker<V, C, OtherCW>

where OtherCW: CustomNodeWalker<Custom = C>,

impl<V, C, CW> Walker<V, C, CW>

where C: CustomNode, V: Visitor<C> + VisitMut, CW: CustomNodeWalker<Custom = C>,

pub fn destruct(self) -> V

Trait Implementations

impl<V, C, CW> Visitor<C> for Walker<V, C, CW>

where C: CustomNode, V: Visitor<C> + VisitMut, CW: CustomNodeWalker<Custom = C>,

fn visit_node(&mut self, node: &mut Node<C>) -> bool

fn visit_block(&mut self, node: &mut NodeBlock) -> bool

fn visit_comment(&mut self, node: &mut NodeComment) -> bool

fn visit_doctype(&mut self, node: &mut NodeDoctype) -> bool

fn visit_raw_node<OtherC: CustomNode>( &mut self, node: &mut RawText<OtherC>, ) -> bool

fn visit_custom(&mut self, node: &mut C) -> bool

fn visit_text_node(&mut self, node: &mut NodeText) -> bool

fn visit_element(&mut self, node: &mut NodeElement<C>) -> bool

fn visit_fragment(&mut self, node: &mut NodeFragment<C>) -> bool

fn visit_open_tag(&mut self, open_tag: &mut OpenTag) -> bool

fn visit_close_tag(&mut self, closed_tag: &mut CloseTag) -> bool

fn visit_attribute(&mut self, attribute: &mut NodeAttribute) -> bool

fn visit_keyed_attribute(&mut self, attribute: &mut KeyedAttribute) -> bool

fn visit_attribute_flag(&mut self, key: &mut NodeName) -> bool

fn visit_attribute_binding( &mut self, key: &mut NodeName, value: &mut FnBinding, ) -> bool

fn visit_attribute_value( &mut self, key: &mut NodeName, value: &mut AttributeValueExpr, ) -> bool

fn visit_invalid_block(&mut self, block: &mut InvalidBlock) -> bool

fn visit_node_name(&mut self, name: &mut NodeName) -> bool

fn visit_rust_code(&mut self, code: RustCode<'_>) -> bool