xrust 0.3.0

Support for XPath, and XSLT
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
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

/// Driver for trees

// Find the string value of the Node
fn node_to_string(node: &RcNode<NodeDefn>) -> String {
  let d = node.data();

  match d.nodetype {
      NodeType::Document => {
        if node.has_no_child() {
	  String::new()
	} else {
	  node.iter_rc().fold(String::new(), |s,c| s + &node_to_string(&c))
	}
      }
      NodeType::Element => {
        if node.has_no_child() {
	  "".to_string()
	} else {
	  node.iter_rc().fold(String::new(), |s,c| s + &node_to_string(&c))
	}
      }
      NodeType::Text => {
        String::from(d.value.as_ref().unwrap())
      }
      NodeType::Attribute |
      NodeType::Comment |
      NodeType::ProcessingInstruction => {
        "".to_string()
      }
  }
}
fn node_to_xml(node: &RcNode<NodeDefn>) -> String {
  let d = node.data();

  match d.nodetype {
      NodeType::Document => {
        if node.has_no_child() {
	  String::new()
	} else {
	  node.iter_rc().fold(String::new(), |s,c| s + &node_to_xml(&c))
	}
      }
      NodeType::Element => {
        if node.has_no_child() {
	  format!("<{}/>", d.name.as_ref().unwrap())
	} else {
	  // TODO: attributes
	  format!("<{}>{}</{}>", d.name.as_ref().unwrap(), node.iter_rc().fold(String::new(), |s,c| s + &node_to_xml(&c)), d.name.as_ref().unwrap())
	}
      }
      NodeType::Text => {
        String::from(d.value.as_ref().unwrap())
      }
      NodeType::Attribute => {
        let mut r = String::new();
        r.push_str(d.name.as_ref().unwrap().as_str());
        r.push_str("='");
        r.push_str(d.value.as_ref().unwrap().as_str());
        r.push_str("'");
        // TODO: delimiters, escaping
	r
      }
      NodeType::Comment => {
        let mut r = String::new();
        r.push_str("<!--");
        r.push_str(d.value.as_ref().unwrap().as_str());
        r.push_str("-->");
	r
      }
      NodeType::ProcessingInstruction => {
        let mut r = String::new();
        r.push_str("<?");
        r.push_str(d.name.as_ref().unwrap().as_str());
        r.push_str(" ");
        r.push_str(d.value.as_ref().unwrap().as_str());
        r.push_str("?>");
	r
      }
  }
}
fn node_to_json(node: &RcNode<NodeDefn>) -> String {
  let d = node.data();

  match d.nodetype {
      NodeType::Document => {
        if node.has_no_child() {
	  "{}".to_string()
	} else {
	  let mut r = String::from("{");
	  r.push_str(node.iter_rc().fold(String::new(), |s,c| s + &node_to_json(&c)).as_str());
	  r.push('}');
	  r
	}
      }
      NodeType::Element => {
        if node.has_no_child() {
	  format!("\"{}\": \"\"", d.name.as_ref().unwrap())
	} else {
	  format!("\"{}\": {}\n", d.name.as_ref().unwrap(), node.iter_rc().fold(String::new(), |s,c| s + &node_to_json(&c)))
	}
      }
      NodeType::Text => {
        format!("\"{}\"", String::from(d.value.as_ref().unwrap()))
      }
      NodeType::Attribute => {
        "".to_string()
      }
      NodeType::Comment => {
        "".to_string()
      }
      NodeType::ProcessingInstruction => {
        "".to_string()
      }
  }
}

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

    #[test]
    fn node_document() {
        RcNode::from(Tree::new(NodeDefn::new(NodeType::Document)));
        assert!(true)
    }
    #[test]
    fn node_element() {
        let d = RcNode::from(Tree::new(NodeDefn::new(NodeType::Document)));
        let e = Tree::new(NodeDefn::new(NodeType::Element).set_name("Test".to_string()));
	d.push_front(e);
        assert_eq!(node_to_string(&d), "");
        assert_eq!(node_to_xml(&d), "<Test/>");
        assert_eq!(node_to_json(&d), "{\"Test\": \"\"}")
    }
    #[test]
    fn node_text() {
        let d = RcNode::from(Tree::new(NodeDefn::new(NodeType::Document)));
        let mut e = Tree::new(NodeDefn::new(NodeType::Element).set_name("Test".to_string()));
        let t = Tree::new(NodeDefn::new(NodeType::Text).set_value("Test text".to_string()));
	e.push_front(t);
	d.push_front(e);
        assert_eq!(node_to_string(&d), "Test text");
        assert_eq!(node_to_xml(&d), "<Test>Test text</Test>")
    }
    #[test]
    fn item_node_to_string() {
        let d = RcNode::from(Tree::new(NodeDefn::new(NodeType::Document)));
        let mut e = Tree::new(NodeDefn::new(NodeType::Element).set_name("Test".to_string()));
        let t = Tree::new(NodeDefn::new(NodeType::Text).set_value("Test text".to_string()));
	e.push_front(t);
	d.push_front(e);
	let i = Item::Node(d);
        assert_eq!(i.to_string(), "Test text");
        assert_eq!(i.to_xml(), "<Test>Test text</Test>")
    }


}