microformats 0.18.1

A union library of the Microformats types and associated parser.
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

use super::*;
use crate::parse::{element, remove_surrounding_whitespace};
pub struct PropertyParser {
    pub(crate) property_elem: ElementPtr,
    base_url: Url,
}

impl PropertyParser {
    pub fn new(property_elem: ElementPtr, base_url: &Url) -> Self {
        Self {
            property_elem,
            base_url: base_url.to_owned(),
        }
    }

    fn discern_textual_item_value(
        &self,
        property_class: &DeclKind,
        item: &Item,
        prop_name: &str,
    ) -> Result<(String, Option<ValueKind>), Error> {
        let base_prop = item
            .properties
            .get(if matches!(property_class, DeclKind::Plain(_)) {
                "name"
            } else {
                "url"
            })
            .and_then(|values| {
                values
                    .iter()
                    .find(|value| matches!(value, PropertyValue::Plain(_) | PropertyValue::Url(_)))
            });

        let defined_prop = item.properties.get(prop_name).and_then(|values| {
            values
                .iter()
                .find(|value| matches!(value, PropertyValue::Plain(_) | PropertyValue::Url(_)))
        });

        let mut resulting_value = base_prop
            .or(defined_prop)
            .cloned()
            .filter(non_empty_property_value);

        if resulting_value.is_none() {
            let plain_text: String = self.property_elem.node.text_content(&self.base_url)?.into();
            resulting_value = Some(PropertyValue::Plain(TextValue::new(plain_text)))
                .filter(non_empty_property_value)
        };

        match resulting_value {
            Some(PropertyValue::Plain(v)) if matches!(property_class, DeclKind::Plain(_)) => Ok((
                prop_name.to_owned(),
                Some(ValueKind::Plain(remove_surrounding_whitespace(
                    v.to_string(),
                ))),
            )),
            Some(PropertyValue::Url(u)) if matches!(property_class, DeclKind::Linked(_)) => {
                Ok((prop_name.to_owned(), Some(ValueKind::Url((*u).clone()))))
            }
            _ => Ok((prop_name.to_owned(), None)),
        }
    }

    fn discern_hypertext_item_value(
        &self,
        _property_class: &DeclKind,
        _item: &Item,
        prop_name: &str,
    ) -> Result<(String, Option<ValueKind>), Error> {
        unimplemented!("use the associated item here for {prop_name} (first one?), ValueKind::Item")
    }

    fn discern_item_value(
        &self,
        property_class: &DeclKind,
        item: &Item,
    ) -> Result<(String, Option<ValueKind>), Error> {
        match property_class {
            DeclKind::Plain(prop_name) | DeclKind::Linked(prop_name) => {
                self.discern_textual_item_value(property_class, item, prop_name)
            }
            DeclKind::Hypertext(prop_name) => {
                self.discern_hypertext_item_value(property_class, item, prop_name)
            }
            _ => unreachable!("define logic for {property_class:#?}"),
        }
    }

    pub fn expand(self, matched_elements: &element::MatchedElements) -> Result<Properties, Error> {
        let mut properties = Properties::default();
        let prop_classes = self.property_elem.node.property_classes();

        for prop_decl in prop_classes {
            let mut property_item = matched_elements
                .expand_item_from_element(Arc::clone(&self.property_elem), &self.base_url)?;
            let (property_name, value) = self.discern_item_value(&prop_decl, &property_item)?;

            property_item.value = value;

            if let Some(values) = properties.get_mut(&property_name) {
                values.push(PropertyValue::Item(property_item));
            } else {
                properties.insert(property_name, vec![PropertyValue::Item(property_item)]);
            }
        }

        Ok(properties)
    }
}

#[cfg(test)]
mod test;