uil_parsers 0.0.3

Parsers for uil.
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


use std::collections::HashMap;
use std::mem;

use uil_shared::markup::{Node, NodeType, TemplateData, View, Template};
use ErrorReporter;

// Library
pub struct Library<E> {
    pub views: HashMap<String, View>,
    pub templates: HashMap<String, Template>,
    err: E,
}

impl<E> Library<E>
    where E: ErrorReporter
{

    pub fn new(reporter: E,
               views: HashMap<String, View>,
               templates: HashMap<String, Template>) -> Library<E>
    {
        Library {
            err: reporter,
            views: views,
            templates: templates
        }
    }

    pub fn get<S: ToString>(&self, s: S) -> Option<&View> {
        self.views.get(&s.to_string())
    }

    pub fn merge(&mut self, other: Library<E>) {
        for (key, val) in other.views.into_iter() {
            self.views.insert(key, val);
        }

        for (key, val) in other.templates.into_iter() {
            self.templates.insert(key, val);
        }
    }

    /// # Resolve the dependencies
    ///
    /// Convert all templates that match a template definition
    /// with a group containing the templates childs.
    ///
    /// Note: this does not resolve data-bindings dependencies.
    pub fn resolve_templates(&mut self) {
        let ref mut views = self.views;
        let ref templates = self.templates;
        let ref err = self.err;
        for (_, view) in views.iter_mut() {
            for node in view.children.iter_mut() {
                Library::<E>::resolve_templates_for_node(
                    &err,
                    &templates,
                    node
                );
            }
        }
    }

    fn resolve_templates_for_node(err: &E,
                                  templates: &HashMap<String, Template>,
                                  node: &mut Node)
    {
        for child in node.children.iter_mut() {

            let mut is_empty = None;
            let test = match child.node_type {
                NodeType::Template(TemplateData { ref path }) => {
                    is_empty = Some(path.clone());
                    templates.get(path)
                }
                _ => None
            };

            match test {
                Some(found) => {
                    mem::swap(
                        child,
                        &mut Node::from_template(
                            found,
                            NodeType::Group
                        )
                    );
                }
                // TODO: Warn if the template name is not valid
                //       (not a data-bindings)
                None => match is_empty {
                    Some(name) => err.log(
                        format!("Warning `{}` template name not found", name)
                    ),
                    None => ()
                }
            }
        }

        for child in node.children.iter_mut() {
            Library::<E>::resolve_templates_for_node(err, templates, child);
        }
    }
}