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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! A collection of functions that are useful for unit testing your html! views.

use crate::VirtualNode;

impl VirtualNode {
    /// Get a vector of all of the VirtualNode children / grandchildren / etc of
    /// your virtual_node that have a label that matches your filter.
    ///
    /// # Examples
    ///
    /// ```rust,ignore
    /// # #[macro_use] extern crate virtual_dom_rs;  fn main() {
    ///
    /// let component = html! {<div>
    ///  <span label="hello",> {"Hi!"} </span>
    ///  <em label="world",> {"There!!"} </em>
    ///  <em label="hello",></em>
    /// </div> };
    ///
    /// let hello_nodes = component.filter_label(|label| {
    ///     label.contains("hello")
    /// });
    ///
    /// assert_eq!(hello_nodes.len(), 2);
    /// }
    /// ```
    pub fn filter_label<'a, F>(&'a self, filter: F) -> Vec<&'a VirtualNode>
    where
        F: Fn(&str) -> bool,
    {
        let mut descendants = vec![];

        for child in self.children.as_ref().unwrap() {
            get_descendants(&mut descendants, &child);
        }

        let mut filtered_descendants = vec![];
        for node in descendants.into_iter() {
            match node.props.get("label") {
                Some(label) => {
                    if filter(label) {
                        filtered_descendants.push(node);
                    }
                }
                None => {}
            };
        }

        filtered_descendants
    }

    /// Get a vector of all of the descendants of this VirtualNode
    /// that have the provided `filter`.
    ///
    /// # Examples
    ///
    /// ```rust,ignore
    /// # #[macro_use] extern crate virtual_dom_rs;  fn main() {
    ///
    /// let component = html! {<div>
    ///  <span label="hello",> {"Hi!"} </span>
    ///  <em label="world",> {"There!!"} </em>
    ///  <em label="hello",></em>
    /// </div> };
    ///
    /// let hello_nodes = component.filter_label_equals("hello");
    ///
    /// assert_eq!(hello_nodes.len(), 2);
    /// }
    /// ```
    pub fn filter_label_equals<'a>(&'a self, label: &str) -> Vec<&'a VirtualNode> {
        self.filter_label(|node_label| node_label == label)
    }
}

fn get_descendants<'a>(descendants: &mut Vec<&'a VirtualNode>, node: &'a VirtualNode) {
    descendants.push(node);

    for child in node.children.as_ref().unwrap() {
        get_descendants(descendants, child);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::HashMap;

    // TODO: Move this test somewhere that we can use the `html!` macro
    //    #[test]
    //    fn filter_label() {
    //        let html = html! {
    //        // Should not pick up labels on the root node
    //        <div label="hello0",>
    //            // This node gets picked up
    //            <span label="hello1",>
    //            </span>
    //            // This node gets picked up
    //            <em label="hello2",>
    //                { "hello there :)!" }
    //            </em>
    //            <div label="world",></div>
    //        </div>
    //        };
    //
    //        let hello_nodes = html.filter_label(|label| label.contains("hello"));
    //
    //        assert_eq!(
    //            hello_nodes.len(),
    //            2,
    //            "2 elements with label containing 'hello'"
    //        );
    //    }

    #[test]
    fn label_equals() {
        let span = VirtualNode::new("span");

        let mut props = HashMap::new();
        props.insert("label".to_string(), "hello".to_string());
        let mut em = VirtualNode::new("em");
        em.props = props;

        let mut html = VirtualNode::new("div");
        html.children.as_mut().unwrap().push(span);
        html.children.as_mut().unwrap().push(em);

        let hello_nodes = html.filter_label_equals("hello");

        assert_eq!(hello_nodes.len(), 1);
    }
}