graph-rdfa-processor 0.3.12

Graph RDFa processor
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

use std::error::Error;

use scraper::{ElementRef, Selector, node::Element};

#[derive(Debug, Clone, Copy)]
pub struct RdfaElement<'a, 'b> {
    pub element_ref: &'b ElementRef<'a>,
    pub element: &'a Element,
    pub name: &'a str,
    pub base: Option<&'a str>,
    pub vocab: Option<&'a str>,
    pub prefix: Option<&'a str>,
    pub lang: Option<&'a str>,
    pub about: Option<&'a str>,
    pub property: Option<&'a str>,
    pub rel: Option<&'a str>,
    pub rev: Option<&'a str>,
    pub src: Option<&'a str>,
    pub href: Option<&'a str>,
    pub type_of: Option<&'a str>,
    pub inlist: Option<&'a str>,
    pub content: Option<&'a str>,
    pub datatype: Option<&'a str>,
    pub datetime: Option<&'a str>,
    pub resource: Option<&'a str>,
}

#[allow(unused)]
impl<'a, 'b> RdfaElement<'a, 'b> {
    pub fn new(element_ref: &'b ElementRef<'a>) -> Result<Self, Box<dyn Error>> {
        let element = element_ref.value();
        let vocab = element.attr("vocab").map(|v| v.trim());
        let base = element_ref
            .select(&Selector::parse("base")?)
            .next()
            .and_then(|e| e.attr("href"))
            .map(|b| {
                let pos_fragment = b.chars().position(|p| p == '#').unwrap_or(b.len());
                &b[0..pos_fragment]
            });
        let name = element.name();
        let prefix = element.attr("prefix");
        let resource = element.attr("resource");
        let lang = element.attr("lang").or_else(|| element.attr("xml:lang"));
        let property = element.attr("property");
        let rel = element.attr("rel");
        let rev = element.attr("rev");
        let type_of = element.attr("typeof");
        let src = element.attr("src");
        let href = element.attr("href");
        let datatype = element.attr("datatype");
        let inlist = element.attr("inlist");
        let content = element.attr("content");
        let about = element.attr("about");
        let datetime = element.attr("datetime");

        Ok(Self {
            element_ref,
            element,
            base,
            name,
            vocab,
            prefix,
            lang,
            about,
            property,
            rel,
            rev,
            src,
            href,
            type_of,
            inlist,
            content,
            datatype,
            datetime,
            resource,
        })
    }

    pub fn has_no_rel_and_no_property(&self) -> bool {
        self.rel.is_none() && self.property.is_none()
    }
    pub fn src_or_href(&self) -> Option<&'a str> {
        self.src.or(self.href)
    }
    pub fn is_inlist(&self) -> bool {
        self.inlist.is_some()
    }

    pub fn has_content_or_datatype(&self) -> bool {
        self.content.is_some() || self.datatype.is_some()
    }
    pub fn has_property(&self) -> bool {
        self.property.is_some()
    }

    pub fn has_non_empty_resource(&self) -> bool {
        self.resource.filter(|c| !c.is_empty()).is_some()
    }
    pub fn has_non_empty_href(&self) -> bool {
        self.href.filter(|c| !c.is_empty()).is_some()
    }
    pub fn has_non_empty_src(&self) -> bool {
        self.src.filter(|c| !c.is_empty()).is_some()
    }
    pub fn has_non_empty_property(&self) -> bool {
        self.property.filter(|c| !c.is_empty()).is_some()
    }
    pub fn has_non_empty_type_of(&self) -> bool {
        self.type_of.filter(|c| !c.is_empty()).is_some()
    }
    pub fn has_about(&self) -> bool {
        self.about.is_some()
    }
    pub fn get_time(&self) -> Option<&'a str> {
        if self.element.name() == "time" || self.datetime.is_some() {
            self.datetime
                .or_else(|| self.element_ref.text().take(1).last())
        } else {
            None
        }
    }
    pub fn texts(&self) -> Vec<&'a str> {
        self.element_ref.text().collect()
    }
    pub fn inner_html(&self) -> String {
        self.element_ref.inner_html()
    }

    pub(crate) fn has_rel_or_rev(&self) -> bool {
        self.rel.is_some() || self.rev.is_some()
    }
}