sitemap 0.4.1

Sitemap parser (reader) and writer
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

//! Contains sitemap reader.
//!
//! # Examples
//!
//! Reading sitemap from file.
//!
//! ```rust
//! use sitemap::reader::{SiteMapReader,SiteMapEntity};
//! use std::fs::File;
//! fn main() {
//!    let mut urls = Vec::new();
//! 	let mut sitemaps = Vec::new();
//! 	let mut errors = Vec::new();
//! 	let file = File::open("tests/documents/sitemap1.xml").expect("Unable to open file.");
//! 	let parser = SiteMapReader::new(file);
//! 	for entity in parser {
//! 		match entity {
//! 			SiteMapEntity::Url(url_entry) => {
//! 				urls.push(url_entry);
//! 			},
//! 			SiteMapEntity::SiteMap(sitemap_entry) => {
//! 				sitemaps.push(sitemap_entry);
//! 			},
//! 			SiteMapEntity::Err(error) => {
//! 				errors.push(error);
//! 			},
//! 		}
//! 	}
//! 	println!("urls = {:?}",urls);
//! 	println!("sitemaps = {:?}",sitemaps);
//! 	println!("errors = {:?}",errors);
//! }
//! ```
use crate::structs;
use xml;
use std::io::Read;
use xml::reader::{EventReader, XmlEvent, Events};
use std::convert::From;

/// A wrapper around an `std::io::Read` instance which provides sitemap parsing.
///
/// It's provides iterator over `SiteMapEntity`.
pub struct SiteMapReader<T: Read + Sized> {
    path: Vec<String>,
    url_item: structs::UrlEntry,
    sitemap_item: structs::SiteMapEntry,
    parser: Events<T>,
}
/// Sitemap entry.
#[derive(Debug,Clone)]
pub enum SiteMapEntity {
    /// Url entry.
    Url(structs::UrlEntry),
    /// Sitemap entry.
    SiteMap(structs::SiteMapEntry),
    /// XML read error.
    Err(xml::reader::Error),
}
impl<T: Read + Sized> SiteMapReader<T> {
    /// Creates a new reader, consuming the given stream.
    pub fn new(source: T) -> SiteMapReader<T> {
        let parser = EventReader::new(source).into_iter();
        SiteMapReader {
            path: Vec::new(),
            url_item: structs::UrlEntry::new(),
            sitemap_item: structs::SiteMapEntry::new(),
            parser: parser,
        }
    }
    fn open_tag(&mut self) {
        if self.path == vec!["urlset", "url"] {
            self.url_item = structs::UrlEntry::new();
        } else if self.path == vec!["sitemapindex", "sitemap"] {
            self.sitemap_item = structs::SiteMapEntry::new();
        }
    }
    fn text_content(&mut self, data: String) {
        if self.path == vec!["urlset", "url", "loc"] {
            self.url_item.loc = structs::Location::from(data);
        } else if self.path == vec!["urlset", "url", "lastmod"] {
            self.url_item.lastmod = structs::LastMod::from(data);
        } else if self.path == vec!["urlset", "url", "changefreq"] {
            self.url_item.changefreq = structs::ChangeFreq::from(data);
        } else if self.path == vec!["urlset", "url", "priority"] {
            self.url_item.priority = structs::Priority::from(data);
        } else if self.path == vec!["sitemapindex", "sitemap", "loc"] {
            self.sitemap_item.loc = structs::Location::from(data);
        } else if self.path == vec!["sitemapindex", "sitemap", "lastmod"] {
            self.sitemap_item.lastmod = structs::LastMod::from(data);
        }
    }
    fn close_tag(&mut self) -> Option<SiteMapEntity> {
        if self.path == vec!["urlset", "url"] {
            return Some(SiteMapEntity::Url(self.url_item.clone()));
        } else if self.path == vec!["sitemapindex", "sitemap"] {
            return Some(SiteMapEntity::SiteMap(self.sitemap_item.clone()));
        }
        return None;
    }
}
impl<T: Read + Sized> Iterator for SiteMapReader<T> {
    type Item = SiteMapEntity;
    fn next(&mut self) -> Option<SiteMapEntity> {
        loop {
            let e = self.parser.next();
            match e {
                Some(e) => {
                    match e {
                        Ok(XmlEvent::StartElement { name, .. }) => {
                            let tag_name = name.local_name.to_lowercase();
                            self.path.push(tag_name.to_string());
                            self.open_tag();
                        }
                        Ok(XmlEvent::EndElement { .. }) => {
                            let entity = self.close_tag();
                            self.path.pop();
                            match entity {
                                Some(entity) => {
                                    return Some(entity);
                                }
                                None => {}
                            }
                        }
                        Ok(XmlEvent::Characters(data)) => {
                            self.text_content(data);
                        }
                        Err(error) => {
                            return Some(SiteMapEntity::Err(error));
                        }
                        _ => {}
                    }
                }
                None => {
                    return None;
                }
            }
        }
    }
}