tour-parser 0.1.0

Tour Template Parser
Documentation 
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
95
96
97
98
99
100
101
102
103
104
105
106

use syn::Result;

use super::{AliasKind, File};
use crate::{
    ast::{Scalar, Scope, StmtTempl},
    common::error,
    syntax::{RenderTempl, RenderValue},
};

/// Template validation.
///
/// Validate early to allows for infallible codegen.
///
/// Will validate:
///
/// - the referenced template by `render` statement exists
pub struct ValidateVisitor<'a> {
    file: &'a File,
}

impl<'a> ValidateVisitor<'a> {
    /// Start validating.
    pub fn validate(file: &'a File) -> Result<()> {
        let me = Self { file };
        me.visit_stmts(&me.file.stmts)
    }

    fn visit_stmts(&self, stmts: &[StmtTempl]) -> Result<()> {
        for stmt in stmts {
            self.visit_stmt(stmt)?;
        }
        Ok(())
    }

    fn visit_stmt(&self, stmt: &StmtTempl) -> Result<()> {
        match stmt {
            StmtTempl::Scalar(scalar) => match scalar {
                Scalar::Static { .. } => {}
                Scalar::Use(_) => {}
                Scalar::Render(RenderTempl { value: RenderValue::Ident(id), block, .. }) => {
                    match (self.file.get_resolved_id(id),block) {
                        (Some(_), None) => {
                            // Ok
                        },
                        (Some(AliasKind::Import(import)), Some((_, block))) => {
                            if import.templ.file().get_block(block).is_none() {
                                error!(id, "cannot find block `{block}` in `{id}`")
                            }
                        },
                        (Some(AliasKind::Block(_)), Some((_, block))) => {
                            error!(id, "cannot render a block `{id}` from a block `{block}`")
                        },
                        (None,_) => {
                            error!(id, "cannot find block/template `{id}`")
                        }
                    }
                },
                Scalar::Render(RenderTempl { value: RenderValue::Path(path), block, .. }) => {
                    match (self.file.get_import_by_path(path), block) {
                        (Some(_), None) => {
                            // Ok
                        },
                        (Some(import), Some((_, block))) => {
                            if import.templ.file().get_block(block).is_none() {
                                error!(path, "cannot find block `{block}` in `{}`", path.value())
                            }
                        },
                        (None,_) => {
                            error!(path, "cannot find template `{}`", path.value())
                        },
                    }
                },
                Scalar::Yield(_) => {}
                Scalar::Item(_) => {}
                Scalar::Expr { .. } => {}
            }
            StmtTempl::Scope(scope) => self.visit_scope(scope)?,
        }

        Ok(())
    }

    fn visit_scope(&self, scope: &Scope) -> Result<()> {
        match scope {
            Scope::Root { stmts } => self.visit_stmts(stmts)?,
            Scope::If { stmts, else_branch, .. } => {
                self.visit_stmts(stmts)?;
                if let Some((_,scope)) = else_branch {
                    self.visit_scope(scope)?;
                }
            },
            Scope::For { stmts, else_branch, .. } => {
                self.visit_stmts(stmts)?;
                if let Some((_,scope)) = else_branch {
                    self.visit_scope(scope)?;
                }
            },
            Scope::Block { .. } => unreachable!("`block` scope should be replaced with `render`")
        }

        Ok(())
    }
}