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

use super::*;
use crate::parse::{
    element::test::{from_html_str, grab_element_from_document},
    ElementRef, MatchedElements,
};
use microformats_types::{KnownClass, TextValue, UrlValue};
use tracing_test::traced_test;
use tracing_unwrap::OptionExt;

#[traced_test]
#[test]
fn plain() -> Result<(), crate::parse::Error> {
    let mut plain_text_dom = from_html_str(
        r#"<div class='h-entry'><a href='/foo' class='p-author h-card'>a <span class='p-tag'>place</span></a></div>"#,
    );
    let plain_text_elem = grab_element_from_document(&plain_text_dom, "a").unwrap_or_log();

    let plain_text_parser = PropertyParser::new(
        Arc::new(ElementRef {
            index: 0,
            node: Node {
                elem: plain_text_elem,
            },
        }),
        &"http://example.com".parse()?,
    );

    let plain_text_history = MatchedElements::for_document_default(&mut plain_text_dom)?;

    similar_asserts::assert_serde_eq!(
        parsed: plain_text_parser.expand(&plain_text_history)?,
        expected: Properties::from_iter( vec![ (
            "author".to_string(),
            vec![PropertyValue::Item(Item {
                r#type: vec![KnownClass::Card.into()],
                properties: Properties::from_iter(vec![
                    (
                        "tag".to_string(),
                        vec![PropertyValue::Plain(TextValue::new("place".to_string()))]
                    ),
                    (
                        "url".to_string(),
                        vec![PropertyValue::Url(UrlValue::new("http://example.com/foo".parse()?))]
                    )
                ]),
                value: Some(ValueKind::Plain("a place".to_string())),
                ..Default::default()
            })]
        ) ]),
        "expanded a direct plain property"
    );

    Ok(())
}

#[traced_test]
#[test]
fn linked() -> Result<(), crate::parse::Error> {
    let mut linked_dom = from_html_str(
        r#"<div class='h-entry'><a href='/foo' class='u-author h-card'>a <span class='p-name'>place</span></a></div>"#,
    );
    let linked_elem = grab_element_from_document(&linked_dom, "a").unwrap_or_log();

    let linked_parser = PropertyParser::new(
        Arc::new(ElementRef {
            index: 0,
            node: Node { elem: linked_elem },
        }),
        &"http://example.com".parse()?,
    );

    let linked_history = MatchedElements::for_document_default(&mut linked_dom)?;

    similar_asserts::assert_serde_eq!(
        parsed: linked_parser.expand(&linked_history)?,
        expected: Properties::from_iter( vec![ (
            "author".to_string(),
            vec![PropertyValue::Item(Item {
                r#type: vec![KnownClass::Card.into()],
                properties: Properties::from_iter(vec![
                    (
                        "name".to_string(),
                        vec![PropertyValue::Plain(TextValue::new("place".to_string()))]
                    ),
                    (
                        "url".to_string(),
                        vec![PropertyValue::Url(UrlValue::new("http://example.com/foo".parse()?))]
                    )
                ]),
                value: Some(ValueKind::Url("http://example.com/foo".parse()?)),
                ..Default::default()
            })]
        ) ]),
        "expanded a direct linked property"
    );
    Ok(())
}