Dynamically importing a module and calling it's functions #1024

mcharytoniuk · 2025-08-26T00:07:05Z

mcharytoniuk
Aug 26, 2025

Hello!

Recently, in #1021 with the help of @schungx I managed to create somewhat complex parser to parse JSX-like expressions with Rhai:

fn template(assets, content, props) {
    assets.assets.add("resouces/controller_foo.tsx");

    component {
        <!DOCTYPE html>
        <LayoutHomepage extraBodyClass="my-extra-class">
            < button
                class="myclass"
                data-foo={props.bar}
                data-fooz={`${props.bar}`}
                data-gooz={if true {
                    component {
                        <div />
                    }
                } else {
                    ":)"
                }}
                disabled
            >
                <b><i><u>test</u></i></b>
                Hello! :D
                {" - "}

                <Note>
                    {if content.is_empty() {
                        component {
                            <div>
                                NOTE EMPTY CONTENT
                            </div>
                        }
                    } else {
                        content
                    }}
                </Note>
            </button>
        </LayoutHomepage>
    }
}

template(#{
    render: || "wow",
    assets: #{
        add: |script| script,
    }
}, "", #{
    bar: "baz tag \" attribute"
})

I am past the parser, the above more or less works, but I have a few questions now:

When I set engine.set_strict_variables(true); it raises erros in the custom syntax (even though variables DO exist in the engine). Is that intended?
When evaluating component all I have is:

    context: &mut EvalContext,
    inputs: &[Expression],
    state: &Dynamic,

is it possible to import a module dynamically with EvalContext and then call a function from the module? I do not want to keep the result in Rust, I want to somehow call it in context, create a new variable, use the result in context again.

I know it might sound silly, but now that I have the components like <LayoutHomepage extraBodyClass="my-extra-class">, I want to import in-context something like "components/LayoutHomepage" as LayoutHomepage;, call it as LayoutHomepage::template(#{ extraBodyClass: "my-extra-class" }) and pass the result down as the original function result.

I tried a few things; using eval in engine, pushing a new module onto GlobalRuntimeState etc but to no avail.

What I generally want to achieve is to this:

fn template(content) {
  component {
    <MyOtherComponent>
      <b>{content}</b>
    </MyOtherComponent>
  }
}

to work exactly like this, at a custom syntax level (parsing already works, now I am at the evaluation stage):

// import added automatically
import "MyOtherComponent" as MyOtherComponent;

fn template(content) {
  MyOtherComponent::template(`<b>${content}</b>`)
}

Any tips? : D

Thank you

The parser in question (runs as a single file), I am implementing render_tag_stack:

example code

#![allow(warnings)]
#![allow(clippy::all)]
use std::collections::VecDeque;
use anyhow::Result;

use rhai::Dynamic;

use rhai::EvalAltResult;

use rhai::EvalContext;

use rhai::Expression;

use rhai::ImmutableString;

use rhai::LexError;

use rhai::ParseError;

use rhai::ParseErrorType;

use rhai::Position;
#[derive(Clone, Debug)]

enum OutputSymbol {

BodyExpression,

Text(String),

TagLeftAnglePlusWhitespace(String),

TagCloseBeforeNamePlusWhitespace(String),

TagName(String),

TagContent(String),

TagAttributeName(String),

TagAttributeValueExpression,

TagAttributeValueString(String),

TagSelfClose,

TagRightAngle,

}
#[derive(Debug)]

enum OutputCombinedSymbol {

BodyExpressionResult(String),

Text(String),

TagLeftAngle,

TagCloseBeforeName,

TagName(String),

TagAttributeName(String),

TagAttributeValue(String),

TagSelfClose,

TagRightAngle,

}
#[derive(Clone, Debug)]

struct Attribute {

pub name: String,

pub value: Option,

}
#[derive(Clone, Debug)]

struct Tag {

pub attributes: Vec,

pub is_closing: bool,

pub is_self_closing: bool,

pub name: String,

}
impl Tag {

pub fn is_component(&self) -> bool {

self.name.chars().next().map_or(false, |first_character| first_character.is_uppercase())

}

}
#[derive(Debug)]

enum OutputSemanticSymbol {

Tag(Tag),

Text(String),

}
#[derive(Clone, Debug)]

enum TagStackChild {

Text(String),

Tag(TagStackNode),

}
#[derive(Clone, Debug)]

struct TagStackNode {

pub children: Vec,

pub is_closed: bool,

pub opening_tag: Option,

}
#[repr(i32)]

enum ParserState {

Start = 0,

OpeningBracket = 1,

Body = 2,

BodyExpression = 3,

TagLeftAnglePlusWhitespace = 4,

TagCloseBeforeNamePlusWhitespace = 5,

TagName = 6,

TagContent = 7,

TagAttributeName = 8,

TagAttributeValue = 9,

TagAttributeValueString = 10,

TagSelfClose = 11,

}
impl TryFrom for ParserState {

type Error = ();
fn try_from(value: i32) -> Result<Self, Self::Error> {
    match value {
        0 => Ok(ParserState::Start),
        1 => Ok(ParserState::OpeningBracket),
        2 => Ok(ParserState::Body),
        3 => Ok(ParserState::BodyExpression),
        4 => Ok(ParserState::TagLeftAnglePlusWhitespace),
        5 => Ok(ParserState::TagCloseBeforeNamePlusWhitespace),
        6 => Ok(ParserState::TagName),
        7 => Ok(ParserState::TagContent),
        8 => Ok(ParserState::TagAttributeName),
        9 => Ok(ParserState::TagAttributeValue),
        10 => Ok(ParserState::TagAttributeValueString),
        11 => Ok(ParserState::TagSelfClose),
        _ => Err(()),
    }
}

}
/// Taken from Tera: https://github.com/Keats/tera/blob/master/src/utils.rs

pub fn escape_html(input: &str) -> String {

let mut output = String::with_capacity(input.len() * 2);
for c in input.chars() {
    match c {
        '&' => output.push_str("&amp;"),
        '<' => output.push_str("&lt;"),
        '>' => output.push_str("&gt;"),
        '"' => output.push_str("&quot;"),
        '\'' => output.push_str("&#x27;"),
        '/' => output.push_str("&#x2F;"),
        _ => output.push(c),
    }
}

output

}
pub fn parse_component(

symbols: &[ImmutableString],

state: &mut Dynamic,

) -> core::result::Result<Option, ParseError> {

// println!("Symbols: {:?}, tag: {:?}", symbols, state.tag());
let last_symbol = symbols.last().unwrap().as_str();

let push_to_state = |state: &mut Dynamic, value: OutputSymbol| match state.as_array_mut() {
    Ok(mut array) => {
        array.push(Dynamic::from(value));

        Ok(())
    }
    Err(err) => Err(LexError::ImproperSymbol(
        symbols.last().unwrap().to_string(),
        format!(
            "Invalid state array {err} at token: {}",
            symbols.last().unwrap()
        ),
    )
    .into_err(Position::NONE)),
};

match ParserState::try_from(state.tag()) {
    Ok(current_state) => match current_state {
        ParserState::Start => {
            *state = Dynamic::from_array(vec![]);
            state.set_tag(ParserState::OpeningBracket as i32);

            Ok(Some("{".into()))
        }
        ParserState::OpeningBracket => {
            state.set_tag(ParserState::Body as i32);

            Ok(Some("$raw$".into()))
        }
        ParserState::Body => match last_symbol {
            "{" => {
                state.set_tag(ParserState::BodyExpression as i32);

                Ok(Some("$inner$".into()))
            }
            "}" => Ok(None),
            "<" => {
                push_to_state(
                    state,
                    OutputSymbol::TagLeftAnglePlusWhitespace(last_symbol.to_string()),
                )?;
                state.set_tag(ParserState::TagLeftAnglePlusWhitespace as i32);

                Ok(Some("$raw$".into()))
            }
            _ => {
                push_to_state(state, OutputSymbol::Text(last_symbol.to_string()))?;
                state.set_tag(ParserState::Body as i32);

                Ok(Some("$raw$".into()))
            }
        },
        ParserState::BodyExpression => match last_symbol {
            "$inner$" => {
                push_to_state(state, OutputSymbol::BodyExpression)?;

                state.set_tag(ParserState::Body as i32);

                Ok(Some("$raw$".into()))
            }
            _ => Err(LexError::ImproperSymbol(
                symbols.last().unwrap().to_string(),
                format!(
                    "Invalid expression block end at token: {}",
                    symbols.last().unwrap()
                ),
            )
            .into_err(Position::NONE)),
        },
        ParserState::TagLeftAnglePlusWhitespace => match last_symbol {
            _ if last_symbol.trim().is_empty() => {
                push_to_state(
                    state,
                    OutputSymbol::TagLeftAnglePlusWhitespace(last_symbol.to_string()),
                )?;
                state.set_tag(ParserState::TagLeftAnglePlusWhitespace as i32);

                Ok(Some("$raw$".into()))
            }
            "/" => {
                push_to_state(
                    state,
                    OutputSymbol::TagCloseBeforeNamePlusWhitespace(last_symbol.to_string()),
                )?;
                state.set_tag(ParserState::TagCloseBeforeNamePlusWhitespace as i32);

                Ok(Some("$raw$".into()))
            }
            _ => {
                push_to_state(state, OutputSymbol::TagName(last_symbol.to_string()))?;
                state.set_tag(ParserState::TagName as i32);

                Ok(Some("$raw$".into()))
            }
        },
        ParserState::TagCloseBeforeNamePlusWhitespace => match last_symbol {
            _ if last_symbol.trim().is_empty() => {
                push_to_state(
                    state,
                    OutputSymbol::TagCloseBeforeNamePlusWhitespace(last_symbol.to_string()),
                )?;
                state.set_tag(ParserState::TagCloseBeforeNamePlusWhitespace as i32);

                Ok(Some("$raw$".into()))
            }
            _ => {
                push_to_state(state, OutputSymbol::TagName(last_symbol.to_string()))?;
                state.set_tag(ParserState::TagName as i32);

                Ok(Some("$raw$".into()))
            }
        },
        ParserState::TagName => match last_symbol {
            ">" => {
                push_to_state(state, OutputSymbol::TagRightAngle)?;
                state.set_tag(ParserState::Body as i32);

                Ok(Some("$raw$".into()))
            }
            _ if last_symbol.trim().is_empty() => {
                push_to_state(state, OutputSymbol::TagContent(last_symbol.to_string()))?;
                state.set_tag(ParserState::TagContent as i32);

                Ok(Some("$raw$".into()))
            }
            _ => {
                push_to_state(state, OutputSymbol::TagName(last_symbol.to_string()))?;
                state.set_tag(ParserState::TagName as i32);

                Ok(Some("$raw$".into()))
            }
        },
        ParserState::TagContent => match last_symbol {
            ">" => {
                push_to_state(state, OutputSymbol::TagRightAngle)?;
                state.set_tag(ParserState::Body as i32);

                Ok(Some("$raw$".into()))
            }
            "{" => Err(LexError::ImproperSymbol(
                symbols.last().unwrap().to_string(),
                format!(
                    "Invalid expression block start at token: {}",
                    symbols.last().unwrap()
                ),
            )
            .into_err(Position::NONE)),
            _ if last_symbol.trim().is_empty() => {
                push_to_state(state, OutputSymbol::TagContent(last_symbol.to_string()))?;
                state.set_tag(ParserState::TagContent as i32);

                Ok(Some("$raw$".into()))
            }
            "/" => {
                push_to_state(state, OutputSymbol::TagSelfClose)?;
                state.set_tag(ParserState::TagSelfClose as i32);

                Ok(Some(">".into()))
            }
            _ => {
                push_to_state(
                    state,
                    OutputSymbol::TagAttributeName(last_symbol.to_string()),
                )?;
                state.set_tag(ParserState::TagAttributeName as i32);

                Ok(Some("$raw$".into()))
            }
        },
        ParserState::TagAttributeName => match last_symbol {
            "=" => {
                state.set_tag(ParserState::TagAttributeValue as i32);

                Ok(Some("$raw$".into()))
            }
            ">" => {
                push_to_state(state, OutputSymbol::TagRightAngle)?;
                state.set_tag(ParserState::Body as i32);

                Ok(Some("$raw$".into()))
            }
            "/" => {
                push_to_state(state, OutputSymbol::TagSelfClose)?;
                state.set_tag(ParserState::TagSelfClose as i32);

                Ok(Some(">".into()))
            }
            _ if last_symbol.trim().is_empty() => {
                push_to_state(state, OutputSymbol::TagContent(last_symbol.to_string()))?;
                state.set_tag(ParserState::TagContent as i32);

                Ok(Some("$raw$".into()))
            }
            _ => {
                push_to_state(
                    state,
                    OutputSymbol::TagAttributeName(last_symbol.to_string()),
                )?;
                state.set_tag(ParserState::TagAttributeName as i32);

                Ok(Some("$raw$".into()))
            }
        },
        ParserState::TagAttributeValue => match last_symbol {
            "$inner$" => {
                state.set_tag(ParserState::TagContent as i32);

                Ok(Some("$raw$".into()))
            }
            "\"" => {
                state.set_tag(ParserState::TagAttributeValueString as i32);

                Ok(Some("$raw$".into()))
            }
            "{" => {
                push_to_state(state, OutputSymbol::TagAttributeValueExpression)?;
                state.set_tag(ParserState::TagAttributeValue as i32);

                Ok(Some("$inner$".into()))
            }
            _ => {
                push_to_state(
                    state,
                    OutputSymbol::TagAttributeName(last_symbol.to_string()),
                )?;
                state.set_tag(ParserState::TagContent as i32);

                Ok(Some("$raw$".into()))
            }
        },
        ParserState::TagAttributeValueString => match last_symbol {
            "\"" => {
                state.set_tag(ParserState::TagContent as i32);

                Ok(Some("$raw$".into()))
            }
            _ => {
                push_to_state(
                    state,
                    OutputSymbol::TagAttributeValueString(last_symbol.to_string()),
                )?;
                state.set_tag(ParserState::TagAttributeValueString as i32);

                Ok(Some("$raw$".into()))
            }
        },
        ParserState::TagSelfClose => match last_symbol {
            ">" => {
                push_to_state(state, OutputSymbol::TagRightAngle)?;
                state.set_tag(ParserState::Body as i32);

                Ok(Some("$raw$".into()))
            }
            _ => Err(LexError::ImproperSymbol(
                symbols.last().unwrap().to_string(),
                format!(
                    "Invalid self-closing tag end at token: {}",
                    symbols.last().unwrap()
                ),
            )
            .into_err(Position::NONE)),
        },
    },
    Err(_) => {
        return Err(LexError::ImproperSymbol(
            symbols.last().unwrap().to_string(),
            format!("Invalid parser state at token: {}", symbols.last().unwrap()),
        )
        .into_err(Position::NONE));
    }
}

}
pub fn render_tag(tag: &Tag) -> String {

let mut result = String::new();
if tag.is_closing {
    result.push_str("</");
    result.push_str(&tag.name);
    result.push('>');

    return result;
}

result.push('<');
result.push_str(&tag.name);

for attribute in &tag.attributes {
    result.push(' ');
    result.push_str(&attribute.name);

    if let Some(value) = &attribute.value {
        result.push('=');
        result.push('"');
        result.push_str(value);
        result.push('"');
    }
}

if tag.is_self_closing {
    result.push_str(" />");
} else {
    result.push('>');
}

result

}
pub fn eval_component(

context: &mut EvalContext,

inputs: &[Expression],

state: &Dynamic,

) -> core::result::Result<Dynamic, Box> {

let mut inputs_deque: VecDeque<&Expression> = inputs.iter().collect();
let mut shift_expression_tree = || {
    if let Some(expression) = inputs_deque.pop_front() {
        Ok(context.eval_expression_tree(expression)?.into_string()?)
    } else {
        Err(Box::new(EvalAltResult::ErrorParsing(
            ParseErrorType::BadInput(LexError::UnexpectedInput(format!(
                "Exprected expression after component block (got nothing)"
            ))),
            Position::NONE,
        )))
    }
};

let mut combined_symbols: Vec<OutputCombinedSymbol> = vec![];

for node in state.as_array_ref()?.iter() {
    match node.clone().try_cast::<OutputSymbol>().unwrap() {
        OutputSymbol::BodyExpression => {
            combined_symbols.push(OutputCombinedSymbol::BodyExpressionResult(
                shift_expression_tree()?,
            ));
        }
        OutputSymbol::TagAttributeValueExpression => {
            let chunk = shift_expression_tree()?;

            match combined_symbols.last_mut() {
                Some(OutputCombinedSymbol::TagAttributeValue(value)) => {
                    value.push_str(&chunk);
                }
                _ => {
                    combined_symbols.push(OutputCombinedSymbol::TagAttributeValue(chunk));
                }
            }
        }
        OutputSymbol::TagLeftAnglePlusWhitespace(_) => match combined_symbols.last_mut() {
            Some(OutputCombinedSymbol::TagLeftAngle) => {}
            _ => {
                combined_symbols.push(OutputCombinedSymbol::TagLeftAngle);
            }
        },
        OutputSymbol::TagCloseBeforeNamePlusWhitespace(_text) => {
            match combined_symbols.last_mut() {
                Some(OutputCombinedSymbol::TagCloseBeforeName) => {}
                _ => {
                    combined_symbols.push(OutputCombinedSymbol::TagCloseBeforeName);
                }
            }
        }
        OutputSymbol::TagContent(_) => {}
        OutputSymbol::TagAttributeValueString(text) => match combined_symbols.last_mut() {
            Some(OutputCombinedSymbol::TagAttributeValue(value)) => {
                value.push_str(&text);
            }
            _ => {
                combined_symbols.push(OutputCombinedSymbol::TagAttributeValue(text));
            }
        },
        OutputSymbol::TagAttributeName(text) => match combined_symbols.last_mut() {
            Some(OutputCombinedSymbol::TagAttributeName(existing_text)) => {
                existing_text.push_str(&text);
            }
            _ => {
                combined_symbols.push(OutputCombinedSymbol::TagAttributeName(text));
            }
        },
        OutputSymbol::TagName(text) => match combined_symbols.last_mut() {
            Some(OutputCombinedSymbol::TagName(existing_text)) => {
                existing_text.push_str(&text);
            }
            _ => {
                combined_symbols.push(OutputCombinedSymbol::TagName(text));
            }
        },
        OutputSymbol::TagSelfClose => {
            combined_symbols.push(OutputCombinedSymbol::TagSelfClose);
        }
        OutputSymbol::TagRightAngle => {
            combined_symbols.push(OutputCombinedSymbol::TagRightAngle);
        }
        OutputSymbol::Text(text) => match combined_symbols.last_mut() {
            Some(OutputCombinedSymbol::Text(existing_text)) => {
                existing_text.push_str(&text);
            }
            _ => {
                combined_symbols.push(OutputCombinedSymbol::Text(text));
            }
        },
    }
}

let mut semantic_symbols: VecDeque<OutputSemanticSymbol> = VecDeque::new();

for output_combined_symbol in combined_symbols {
    match output_combined_symbol {
        OutputCombinedSymbol::BodyExpressionResult(result) => {
            match semantic_symbols.back_mut() {
                Some(OutputSemanticSymbol::Text(existing_text)) => {
                    existing_text.push_str(&result);
                }
                _ => {
                    semantic_symbols.push_back(OutputSemanticSymbol::Text(result));
                }
            }
        }
        OutputCombinedSymbol::Text(text) => match semantic_symbols.back_mut() {
            Some(OutputSemanticSymbol::Text(existing_text)) => {
                existing_text.push_str(&text.trim());
            }
            _ => {
                semantic_symbols.push_back(OutputSemanticSymbol::Text(text.trim().to_string()));
            }
        },
        OutputCombinedSymbol::TagLeftAngle => match semantic_symbols.back_mut() {
            Some(OutputSemanticSymbol::Tag(_)) | Some(OutputSemanticSymbol::Text(_)) => {
                semantic_symbols.push_back(OutputSemanticSymbol::Tag(Tag {
                    attributes: vec![],
                    is_closing: false,
                    is_self_closing: false,
                    name: String::new(),
                }));
            }
            last_symbol => {
                return Err(Box::new(EvalAltResult::ErrorCustomSyntax(
                    format!("Unexpected tag opening after {last_symbol:?}"),
                    Vec::new(),
                    Position::NONE,
                )));
            }
        },
        OutputCombinedSymbol::TagCloseBeforeName => match semantic_symbols.back_mut() {
            Some(OutputSemanticSymbol::Tag(Tag { is_closing, .. })) => {
                *is_closing = true;
            }
            _ => {
                return Err(Box::new(EvalAltResult::ErrorCustomSyntax(
                    "Unexpected tag closing".to_string(),
                    Vec::new(),
                    Position::NONE,
                )));
            }
        },
        OutputCombinedSymbol::TagName(name) => match semantic_symbols.back_mut() {
            Some(OutputSemanticSymbol::Tag(Tag {
                name: existing_name,
                ..
            })) => {
                *existing_name = name;
            }
            _ => {
                return Err(Box::new(EvalAltResult::ErrorCustomSyntax(
                    "Unexpected tag name".to_string(),
                    Vec::new(),
                    Position::NONE,
                )));
            }
        },
        OutputCombinedSymbol::TagAttributeName(name) => match semantic_symbols.back_mut() {
            Some(OutputSemanticSymbol::Tag(Tag { attributes, .. })) => {
                attributes.push(Attribute { name, value: None });
            }
            _ => {
                return Err(Box::new(EvalAltResult::ErrorCustomSyntax(
                    "Unexpected tag attribute name".to_string(),
                    Vec::new(),
                    Position::NONE,
                )));
            }
        },
        OutputCombinedSymbol::TagAttributeValue(value) => match semantic_symbols.back_mut() {
            Some(OutputSemanticSymbol::Tag(Tag { attributes, .. })) => {
                if let Some(last_attribute) = attributes.last_mut() {
                    last_attribute.value = Some(escape_html(&value));
                } else {
                    return Err(Box::new(EvalAltResult::ErrorCustomSyntax(
                        "Attribute value without name".to_string(),
                        Vec::new(),
                        Position::NONE,
                    )));
                }
            }
            _ => {
                return Err(Box::new(EvalAltResult::ErrorCustomSyntax(
                    "Unexpected tag attribute value".to_string(),
                    Vec::new(),
                    Position::NONE,
                )));
            }
        },
        OutputCombinedSymbol::TagSelfClose => match semantic_symbols.back_mut() {
            Some(OutputSemanticSymbol::Tag(Tag {
                is_self_closing, ..
            })) => {
                *is_self_closing = true;
            }
            _ => {
                return Err(Box::new(EvalAltResult::ErrorCustomSyntax(
                    "Unexpected self-closing tag".to_string(),
                    Vec::new(),
                    Position::NONE,
                )));
            }
        },
        OutputCombinedSymbol::TagRightAngle => {}
    }
}

let mut tag_stack = TagStackNode {
    children: vec![],
    is_closed: false,
    opening_tag: None,
};

build_tag_stack(&mut tag_stack, &mut semantic_symbols)?;

let rendered_tag_stack = render_tag_stack(context, &tag_stack)?;

Ok(Dynamic::from(rendered_tag_stack))

}
fn build_tag_stack<'node>(

current_node: &'node mut TagStackNode,

semantic_symbols: &mut VecDeque,

) -> core::result::Result<(), Box> {

let next_symbol = semantic_symbols.pop_front();
match next_symbol {
    Some(OutputSemanticSymbol::Tag(tag)) => {
        if tag.is_closing {
            if let Some(opening_tag) = &current_node.opening_tag {
                if opening_tag.name != tag.name {
                    return Err(Box::new(EvalAltResult::ErrorCustomSyntax(
                        format!(
                            "Mismatched closing tag: expected </{}>, got </{}>",
                            opening_tag.name, tag.name
                        ),
                        Vec::new(),
                        Position::NONE,
                    )));
                }
            } else {
                return Err(Box::new(EvalAltResult::ErrorCustomSyntax(
                    format!("Unexpected closing tag: </{}>", tag.name),
                    Vec::new(),
                    Position::NONE,
                )));
            }

            current_node.is_closed = true;

            Ok(())
        } else if tag.is_self_closing {
            current_node.children.push(TagStackChild::Tag(TagStackNode {
                children: vec![],
                is_closed: false,
                opening_tag: Some(tag),
            }));

            build_tag_stack(current_node, semantic_symbols)
        } else {
            let mut child_node = TagStackNode {
                children: vec![],
                is_closed: false,
                opening_tag: Some(tag),
            };

            build_tag_stack(&mut child_node, semantic_symbols)?;

            current_node.children.push(TagStackChild::Tag(child_node));

            build_tag_stack(current_node, semantic_symbols)
        }
    }
    Some(OutputSemanticSymbol::Text(text)) => {
        if !text.is_empty() {
            current_node.children.push(TagStackChild::Text(text));
        }

        build_tag_stack(current_node, semantic_symbols)
    },
    None => Ok(()),
}

}
fn render_tag_stack<'node>(

context: &mut EvalContext,

current_node: &'node TagStackNode,

) -> core::result::Result<String, Box> {

let mut result = String::new();
if let Some(opening_tag) = &current_node.opening_tag && !opening_tag.is_component() {
    result.push_str(&render_tag(opening_tag));
}

for child in &current_node.children {
    match child {
        TagStackChild::Text(text) => {
            result.push_str(text);
        }
        TagStackChild::Tag(tag_node) => {
            result.push_str(&render_tag_stack(context, tag_node)?);
        }
    }
}

if let Some(opening_tag) = &current_node.opening_tag && current_node.is_closed && !opening_tag.is_component() {
    result.push_str(&format!("</{}>", opening_tag.name));
}

if let Some(opening_tag) = &current_node.opening_tag && opening_tag.is_component() {
    // let module = context.engine().module_resolver().resolve(
    //     context.engine(),
    //     None,
    //     format!("shortcodes/{}.rhai", opening_tag.name).as_str(),
    //     Position::NONE,
    // )?;
    // println!("Module: {:#?}", module);
    // context.global_runtime_state_mut().push_import(opening_tag.name.clone(), module);
    // // context.engine().eval::<()>("import \"shortcodes/LayoutHomepage\" as LayoutHomepage;")?;
    //
    // context.global_runtime_state_mut().iter_imports().for_each(|(name, module)| {
    //     println!("imported module: {} {:#?}", name, module);
    // });
    // context.iter_namespaces().for_each(|module| {
    //     println!("regsitered module: {:#?}", module);
    // });
    // context.call_fn("Note::template", (
    //     Dynamic::from(""),
    //     Dynamic::from(""),
    //     Dynamic::from(""),
    // ))?;
}

Ok(result)

}
#[cfg(test)]

mod tests {

use rhai::Engine;
use super::*;

#[test]
fn test_docs_parser() -> Result<()> {
    let mut engine = Engine::new();

    engine.set_fail_on_invalid_map_property(true);
    engine.set_max_expr_depths(256, 256);
    // engine.set_strict_variables(true);

    engine.register_custom_syntax_without_look_ahead_raw(
        "component",
        parse_component,
        true,
        eval_component,
    );

    println!(
        "{}",
        engine.eval::<String>(
            r#"
        fn template(assets, content, props) {
            assets.assets.add("resouces/controller_foo.tsx");

            component {
                <!DOCTYPE html>
                <LayoutHomepage extraBodyClass="my-extra-class">
                    < button
                        class="myclass"
                        data-foo={props.bar}
                        data-fooz={`${props.bar}`}
                        data-gooz={if true {
                            component {
                                <div />
                            }
                        } else {
                            ":)"
                        }}
                        disabled
                    >
                        <b><i><u>test</u></i></b>
                        Hello! :D
                        {" - "}

                        <Note>
                            {if content.is_empty() {
                                component {
                                    <div>
                                        NOTE EMPTY CONTENT
                                    </div>
                                }
                            } else {
                                content
                            }}
                        </Note>
                    </button>
                </LayoutHomepage>
            }
        }

        template(#{
            render: || "wow",
            assets: #{
                add: |script| script,
            }
        }, "", #{
            bar: "baz tag \" attribute"
        })
    "#
        )?
    );

    assert!(false);

    Ok(())
}

}

Answered by mcharytoniuk

Aug 27, 2025

Ok, I finally managed to figure it out. Thanks a lot for the help @schungx !

I've added the meta module builder:

use std::sync::Arc;

use anyhow::Result;
use rhai::Engine;
use rhai::Module;
use rhai::Scope;

use super::component_reference::ComponentReference;
use super::component_registry::ComponentRegsitry;

pub struct ComponentMetaModule {
    component_registry: Arc<ComponentRegsitry>,
}

impl ComponentMetaModule {
    pub fn into_global_module(self, engine: &Engine) -> Result<Module> {
        let mut meta_script = String::new();

        for entry in &self.component_registry.components {
            let ComponentReference {
                global_fn_name,
                name,
      …

View full answer

schungx · 2025-08-26T04:04:46Z

schungx
Aug 26, 2025
Maintainer

When I set engine.set_strict_variables(true); it raises erros in the custom syntax (even though variables DO exist in the engine). Is that intended?

I'll have to look into that. Would you give an example?

is it possible to import a module dynamically with EvalContext and then call a function from the module? I do not want to keep the result in Rust, I want to somehow call it in context, create a new variable, use the result in context again.

What you need is a way to import a module, which can easily be obtained by the Engine's module_resolver. Just call resolve and it gives you a Module back.

Now if you'd like to call a function from that module, push it into the GlobalRuntimeState then pop it after use.

Since you said you've already tried it, can you let me know how it didn't work?

Normally, we'd prep up the Engine with all the required modules, or at least namespaces, so they are already available. However, it seems like you want it dynamic, which is for the system to load a script file on-fly when it encounters a tag.

0 replies

mcharytoniuk · 2025-08-26T09:15:44Z

mcharytoniuk
Aug 26, 2025
Author

When I set engine.set_strict_variables(true); it raises erros in the custom syntax (even though variables DO exist in the engine). Is that intended?

I'll have to look into that. Would you give an example?

is it possible to import a module dynamically with EvalContext and then call a function from the module? I do not want to keep the result in Rust, I want to somehow call it in context, create a new variable, use the result in context again.

What you need is a way to import a module, which can easily be obtained by the Engine's module_resolver. Just call resolve and it gives you a Module back.

Now if you'd like to call a function from that module, push it into the GlobalRuntimeState then pop it after use.

Since you said you've already tried it, can you let me know how it didn't work?

Yeah, example is in that file I pasted. :) I know it's long but it runs standalone without modifications. If you set up a new project with just that file, add Rhai to cargo, uncomment strict variables, then run cargo test, it will show up.

Normally, we'd prep up the Engine with all the required modules, or at least namespaces, so they are already available. However, it seems like you want it dynamic, which is for the system to load a script file on-fly when it encounters a tag.

Ok, prepping the engine can also work, because I can just scan the directory with "components" upfront and add each of them as a module. It doesn't need to be dynamic, I am just looking for any way to get this to work. :D

I couldn't figure that out though; I tried importing a module like "LayoutHomepage", then calling "LayoutHomepage::template" function, but that didn't work. I got a message that a function does not exist. Is there some specific syntax somewhere for calling functions from specific modules?

The example from the docs that explains how to call functions in Rust from script or AST works, but that is not exactly this case, and I can't find examples on getting it to work with imported modules either.

If you could comment on some of my points above that would help a lot also.

In the meantime, I will try to push a module function onto a global state and pop it as you say, then come back. Thanks for that tip.

Edit: I tried pushing the module onto GlobalRuntimeState with push_import, then evaluating the code, but I get a message that the specified function does not exist :

let module = context.engine().module_resolver().resolve(
    context.engine(),
    None,
    format!("shortcodes/{}.rhai", opening_tag.name).as_str(),
    Position::NONE,
)?;

context.global_runtime_state_mut().push_import(opening_tag.name.clone(), module);

Function not found:

context.call_fn(format!("{}::template", opening_tag.name), (
  Dynamic::from(""),
  Dynamic::from(""),
  Dynamic::from(""),
))?;

Also, my other issue is - Is there a way to call a function within the context of a Rhai script? I want it to be able to access local variables from Rhai function (positional arguments), without transferring them to Rust and back.

Edit 2:

if I import static modules:

engine.register_static_module("Note", note_module);

Then this works:

println!("Eval result: {:#?}", context.engine().eval::<Dynamic>("Note::template(1, 2, 3)")?);

This doesn't (Error: Function not found Note::template):

context.call_fn("Note::template", (
    Dynamic::from(""),
    Dynamic::from(""),
    Dynamic::from(""),
))?;

8 replies

schungx Aug 26, 2025
Maintainer

I think you're over complicating.

The idea is to use import just before the type is being used. That just how Rhai does things. So the import style is sound.

Or you can prefetch all your types, which means you should be able to make their names unique and just make all of them global.

mcharytoniuk Aug 26, 2025
Author

I think you're over complicating.

Honestly, I am extremely happy to hear that. :D I really want to make this as simple as possible.

The idea is to use import just before the type is being used. That just how Rhai does things. So the import style is sound.

Or you can prefetch all your types, which means you should be able to make their names unique and just make all of them global.

So how should I import those modules instead? Especially, how can I register a function like this one in the engine using just Rust API? I wasn't able to find any relevant example in the docs or the codebase.

fn Note__Template__something1234(context, props, content) {
  import "Note" as Note;
  
  Note::template(context, props, content)
}

Can you please give me an example how can I register that type of thing correctly?

schungx Aug 27, 2025
Maintainer

So how should I import those modules instead? Especially, how can I register a function like this one in the engine using just Rust API?

I think it should work as you wrote it?

import automatically finds the source file and loads it into a module namespace. You shouldn't need to do anything special.

Maybe I'm missing something regarding your requirements.

mcharytoniuk Aug 27, 2025
Author

Maybe I will try to wrap it up the way I can, and come back with something more complete, optimize it later. It should be easier to explain that way.

In general I want users to not have to create such functions. From their perspective I want them to only need to embed a component with something like <FooComponent />, and behind the scenes the engine should import the module, register a global function with some generated unique ID like FooComponent_123 that does the import, call FooComponent_123::template etc, and all that should be happening without writing any code on their part, or even seeing those functions. I need a lot of sugar in the code. :D

schungx Aug 27, 2025
Maintainer

I think here is where I'm losing you. Your custom syntax gets run in Rust where you can technically call the component constructor function. .

In your custom syntax, <FooComponent /> gets parsed to let you know the user wants a FooComponent. And I assume the FooComponent constructor resides in some file called components/foo.rhai or something.

You can then generate the following scriptlet:

import "components/foo" as FooComponent;

FooComponent::template(...)

I assume the template function will get you the relevant HTML output.

You get this output as a string and then you continue your work.

Your user does not see any of these functions, nor do they need to call any weird functions, nor do they import any modules themselves. They just write HTML inside the custom syntax and Rhai will faithfully generate a full HTML text.

Is there anything I missed that won't work for you?

mcharytoniuk · 2025-08-27T18:23:42Z

mcharytoniuk
Aug 27, 2025
Author

Ok, I finally managed to figure it out. Thanks a lot for the help @schungx !

I've added the meta module builder:

use std::sync::Arc;

use anyhow::Result;
use rhai::Engine;
use rhai::Module;
use rhai::Scope;

use super::component_reference::ComponentReference;
use super::component_registry::ComponentRegsitry;

pub struct ComponentMetaModule {
    component_registry: Arc<ComponentRegsitry>,
}

impl ComponentMetaModule {
    pub fn into_global_module(self, engine: &Engine) -> Result<Module> {
        let mut meta_script = String::new();

        for entry in &self.component_registry.components {
            let ComponentReference {
                global_fn_name,
                name,
                path,
            } = entry.value();

            meta_script.push_str(&format!(
                r#"
                    import "{path}" as {name};
    
                    fn {global_fn_name}(context, props, content) {{
                        {name}::template(context, props, content)
                    }}
                "#
            ));
        }

        let meta_module_ast = engine.compile(meta_script)?;

        Ok(Module::eval_ast_as_new(
            Scope::new(),
            &meta_module_ast,
            &engine,
        )?)
    }
}

impl From<Arc<ComponentRegsitry>> for ComponentMetaModule {
    fn from(component_registry: Arc<ComponentRegsitry>) -> Self {
        Self { component_registry }
    }
}

Then I register it in the engine:

let meta_module = ComponentMetaModule::from(component_registry.clone()).into_global_module(&engine)?;

engine.register_global_module(meta_module.into());

Then, later, during evaluation I can do:

Ok(eval_context
    .call_fn::<Dynamic>(
        component_registry
            .get_global_fn_name(&opening_tag.name)
            .or_else(|err| {
                Err(EvalAltResult::ErrorRuntime(
                    format!("Component not found: {err}").into(),
                    rhai::Position::NONE,
                ))
            })?,
        (
            Dynamic::from(component_context.clone()),
            Dynamic::from_map(props),
            Dynamic::from(result.clone()),
        ),
    )
    .or_else(|err| {
        Err(EvalAltResult::ErrorRuntime(
            format!("Failed to call component function: {err}").into(),
            rhai::Position::NONE,
        ))
    })?)

I think this is what I was missing. : D Finally works, thanks again

9 replies

schungx Sep 1, 2025
Maintainer

Now you'd only need to update the syntax-highlighting for your... er... RSX?

BTW, the new drop will also have Engine::eval_fn_call so people won't have to artificially create a scriptlet and can just use Dynamic values as arguments instead of having to text-print them. However, it won't help your case because you'd need to import a module dynamically, so you'd have to go with the scriptlet route.

mcharytoniuk Sep 4, 2025
Author

@schungx I've tried out eval_fn_call. Not everything works much faster, rendering times for multiple markdown pages with Rhai components in my case went down from ~80ms to ~50ms (because I didn't have to create multiple engine instances), so that's a ~30% speedup. :D Thanks a lot for that.

schungx Sep 5, 2025
Maintainer

How did you get around the fact that you need to load modules dynamically?

I don't think you can specify a global runtime with eval_fn_call... And you'd need an import statement somewhere...

mcharytoniuk Sep 5, 2025
Author

You can take a look here: https://github.com/intentee/poet/blob/main/src/rhai_template_factory.rs#L97-L123

I still use the global metamodule for function names (https://github.com/intentee/poet/blob/5e2fd7760ed5fc99b3365a92c5e52f8e8fa65c3f/src/rhai_components/component_meta_module.rs#L26-L32) , but now I need just a single Engine instance, and I started to register static modules. I never really needed to load them dynamically, I just didn't know about register_static_module when I mentioned that in the past; I just thought that was the only way to do it. : D

Then I render components with eval_fn_call here: https://github.com/intentee/poet/blob/5e2fd7760ed5fc99b3365a92c5e52f8e8fa65c3f/src/rhai_template_renderer.rs#L31-L47

schungx Sep 5, 2025
Maintainer

Ah now I understand. You preload all the modules.

Dynamically importing a module and calling it's functions #1024

Uh oh!

Uh oh!

mcharytoniuk Aug 26, 2025

Replies: 3 comments · 17 replies

Uh oh!

Uh oh!

schungx Aug 26, 2025 Maintainer

Uh oh!

Uh oh!

mcharytoniuk Aug 26, 2025 Author

Uh oh!

Uh oh!

schungx Aug 26, 2025 Maintainer

Uh oh!

mcharytoniuk Aug 26, 2025 Author

Uh oh!

Uh oh!

schungx Aug 27, 2025 Maintainer

Uh oh!

mcharytoniuk Aug 27, 2025 Author

Uh oh!

Uh oh!

schungx Aug 27, 2025 Maintainer

Uh oh!

Uh oh!

mcharytoniuk Aug 27, 2025 Author

Uh oh!

schungx Sep 1, 2025 Maintainer

Uh oh!

mcharytoniuk Sep 4, 2025 Author

Uh oh!

schungx Sep 5, 2025 Maintainer

Uh oh!

Uh oh!

mcharytoniuk Sep 5, 2025 Author

Uh oh!

Uh oh!

schungx Sep 5, 2025 Maintainer

mcharytoniuk
Aug 26, 2025

Replies: 3 comments 17 replies

schungx
Aug 26, 2025
Maintainer

mcharytoniuk
Aug 26, 2025
Author

schungx Aug 26, 2025
Maintainer

mcharytoniuk Aug 26, 2025
Author

schungx Aug 27, 2025
Maintainer

mcharytoniuk Aug 27, 2025
Author

schungx Aug 27, 2025
Maintainer

mcharytoniuk
Aug 27, 2025
Author

schungx Sep 1, 2025
Maintainer

mcharytoniuk Sep 4, 2025
Author

schungx Sep 5, 2025
Maintainer

mcharytoniuk Sep 5, 2025
Author

schungx Sep 5, 2025
Maintainer