thymeleaf 0.1.0-beta.1

A framework-neutral Thymeleaf-compatible dynamic template engine for Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use std::sync::Arc;

use crate::TemplateMode;
use crate::cdatasection::{
    AbstractCDATASectionProcessor, ICDATASectionProcessor, ICDATASectionStructureHandler,
};
use crate::context::ITemplateContext;
use crate::exceptions::{TemplateEngineException, TemplateProcessingException};
use crate::model::ICDATASection;
use crate::processor::IProcessor;

use super::expression_processing_error;

type CDATACallback = Box<
    dyn Fn(
            &dyn ITemplateContext,
            &dyn ICDATASection,
            &mut dyn ICDATASectionStructureHandler,
        ) -> Result<(), Box<dyn TemplateEngineException>>
        + Send
        + Sync,
>;

/// 对 CDATA 内容应用当前上下文 Inliner 的 Processor。
/// 对应 Java: `org.thymeleaf.standard.processor.StandardInliningCDATASectionProcessor`。
pub struct StandardInliningCDATASectionProcessor {
    processor: AbstractCDATASectionProcessor<CDATACallback>,
}

impl StandardInliningCDATASectionProcessor {
    /// Java precedence。
    pub const PRECEDENCE: i32 = 1000;

    /// 创建指定模板模式的内联 Processor。
    /// 对应 Java 语义：`StandardInliningCDATASectionProcessor` 的 `new` 行为（Rust 侧辅助/私有路径）。
    pub fn new(template_mode: TemplateMode) -> Result<Self, TemplateProcessingException> {
        let callback: CDATACallback = Box::new(|context, cdata_section, structure_handler| {
            let Some(inliner) = context.get_inliner() else {
                return Ok(());
            };
            if let Some(inlined) = inliner
                .inline_cdata_section(context, cdata_section)
                .map_err(|error| {
                    expression_processing_error("Could not inline CDATA section", error)
                })?
            {
                structure_handler.set_content_sequence(Arc::from(inlined));
            }
            Ok(())
        });
        Ok(Self {
            processor: AbstractCDATASectionProcessor::new(
                Some(template_mode),
                Self::PRECEDENCE,
                "org.thymeleaf.standard.processor.StandardInliningCDATASectionProcessor",
                callback,
            )
            .map_err(|error| {
                TemplateProcessingException::with_cause(
                    Some("Could not create inlining CDATA processor".to_owned()),
                    error,
                )
            })?,
        })
    }
}

impl IProcessor for StandardInliningCDATASectionProcessor {
    fn as_cdata_section_processor(&self) -> Option<&dyn ICDATASectionProcessor> {
        Some(self)
    }

    fn class_name(&self) -> &'static str {
        self.processor.class_name()
    }
    fn get_template_mode(&self) -> Option<TemplateMode> {
        self.processor.get_template_mode()
    }
    fn get_precedence(&self) -> i32 {
        self.processor.get_precedence()
    }
}

impl ICDATASectionProcessor for StandardInliningCDATASectionProcessor {
    fn process(
        &self,
        context: &dyn ITemplateContext,
        cdata_section: &dyn ICDATASection,
        structure_handler: &mut dyn ICDATASectionStructureHandler,
    ) -> Result<(), Box<dyn TemplateEngineException>> {
        self.processor
            .process(context, cdata_section, structure_handler)
    }
}