rss-rs 0.3.2

Deprecated. This project has been merged with the `rss` crate.
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

use quick_xml::{XmlReader, Event, Element};

use fromxml::{self, FromXml};
use error::Error;
use category::Category;
use guid::Guid;
use enclosure::Enclosure;
use source::Source;
use extension::ExtensionMap;
use extension::itunes::ITunesItemExtension;
use extension::dublincore::DublinCoreExtension;

/// A representation of the `<item>` element.
#[derive(Debug, Default, Clone, PartialEq)]
pub struct Item {
    /// The title of the item.
    pub title: Option<String>,
    /// The URL of the item.
    pub link: Option<String>,
    /// The item synopsis.
    pub description: Option<String>,
    /// The email address of author of the item.
    pub author: Option<String>,
    /// The categories the item belongs to.
    pub categories: Vec<Category>,
    /// The URL for the comments page of the item.
    pub comments: Option<String>,
    /// The description of a media object that is attached to the item.
    pub enclosure: Option<Enclosure>,
    /// A unique identifier for the item.
    pub guid: Option<Guid>,
    /// The date the item was published.
    pub pub_date: Option<String>,
    /// The RSS channel the item came from.
    pub source: Option<Source>,
    /// The HTML contents of the item.
    pub content: Option<String>,
    /// The extensions for the item.
    pub extensions: ExtensionMap,
    /// The iTunes extension for the item.
    pub itunes_ext: Option<ITunesItemExtension>,
    /// The Dublin Core extension for the item.
    pub dublin_core_ext: Option<DublinCoreExtension>,
}

impl FromXml for Item {
    fn from_xml<R: ::std::io::BufRead>(mut reader: XmlReader<R>,
                                       _: Element)
                                       -> Result<(Self, XmlReader<R>), Error> {
        let mut item = Item::default();

        while let Some(e) = reader.next() {
            match e {
                Ok(Event::Start(element)) => {
                    match element.name() {
                        b"category" => {
                            let (category, reader_) = try!(Category::from_xml(reader, element));
                            reader = reader_;
                            item.categories.push(category);
                        }
                        b"guid" => {
                            let (guid, reader_) = try!(Guid::from_xml(reader, element));
                            reader = reader_;
                            item.guid = Some(guid);
                        }
                        b"enclosure" => {
                            let (enclosure, reader_) = try!(Enclosure::from_xml(reader, element));
                            reader = reader_;
                            item.enclosure = Some(enclosure);
                        }
                        b"source" => {
                            let (source, reader_) = try!(Source::from_xml(reader, element));
                            reader = reader_;
                            item.source = Some(source);
                        }
                        b"title" => item.title = element_text!(reader),
                        b"link" => item.link = element_text!(reader),
                        b"description" => item.description = element_text!(reader),
                        b"author" => item.author = element_text!(reader),
                        b"comments" => item.comments = element_text!(reader),
                        b"pubDate" => item.pub_date = element_text!(reader),
                        b"content:encoded" => item.content = element_text!(reader),
                        _ => {
                            if let Some((ns, name)) = fromxml::extension_name(&element) {
                                parse_extension!(reader, element, ns, name, item.extensions);
                            } else {
                                skip_element!(reader);
                            }
                        }
                    }
                }
                Ok(Event::End(_)) => {
                    if !item.extensions.is_empty() {
                        if let Some(map) = item.extensions.remove("itunes") {
                            item.itunes_ext = Some(ITunesItemExtension::from_map(map));
                        }

                        if let Some(map) = item.extensions.remove("dc") {
                            item.dublin_core_ext = Some(DublinCoreExtension::from_map(map));
                        }
                    }

                    return Ok((item, reader));
                }
                Err(err) => return Err(err.into()),
                _ => {}
            }
        }

        Err(Error::EOF)
    }
}