parsoid 0.10.1

Wrapper around Parsoid HTML that provides convenient accessors for processing and manipulation
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
140
141
142

// SPDX-FileCopyrightText: 2024 Kunal Mehta <legoktm@debian.org>
// SPDX-License-Identifier: GPL-3.0-or-later
use crate::prelude::*;
use crate::tests::test_client;
use anyhow::Result;
use std::collections::HashMap;

#[tokio::test]
async fn test_refs() -> Result<()> {
    let client = test_client::testwp_client();
    let code = client.get("Mwbot-rs/Cite").await?.into_mutable();
    let ref_links = code.filter_reference_links();
    dbg!(&ref_links);
    assert_eq!(
        ref_links.len(),
        code.descendants()
            .filter_map(|node| node.as_reference_link())
            .count()
    );

    let all_refs: HashMap<_, _> = code
        .filter_references()
        .into_iter()
        .map(|ref_| (ref_.id(), ref_))
        .collect();
    assert_eq!(
        all_refs.len(),
        code.descendants()
            .filter_map(|node| node.as_reference())
            .count()
    );

    assert_eq!(ref_links.len(), 4);
    // refs[0] == <ref>This is a [[reference]].</ref>
    assert_eq!(ref_links[0].group()?, None);
    assert_eq!(ref_links[0].name()?, None);
    assert_eq!(ref_links[0].text_contents(), "[1]");
    assert_eq!(
        ref_links[0].reference_id()?,
        "mw-reference-text-cite_note-1"
    );
    assert_eq!(ref_links[0].id(), "cite_ref-1");
    assert_eq!(
        all_refs
            .get(&ref_links[0].reference_id()?)
            .unwrap()
            .contents()
            .text_contents(),
        "This is a reference."
    );
    assert_eq!(ref_links[1].name()?, Some("foo".to_string()));
    assert_eq!(
        ref_links[1].reference_id()?,
        "mw-reference-text-cite_note-foo-2"
    );
    assert_eq!(ref_links[1].id(), "cite_ref-foo_2-0");
    // first use of the reference, so it isn't reused
    assert!(!ref_links[1].is_reused()?);
    assert_eq!(
        all_refs
            .get(&ref_links[1].reference_id()?)
            .unwrap()
            .contents()
            .text_contents(),
        "Named reference."
    );
    assert_eq!(ref_links[2].name()?, Some("foo".to_string()));
    assert_eq!(
        ref_links[2].reference_id()?,
        "mw-reference-text-cite_note-foo-2"
    );
    assert_eq!(ref_links[2].id(), "cite_ref-foo_2-1");
    // second use of it, so it is reused
    assert!(ref_links[2].is_reused()?);
    assert_eq!(
        all_refs
            .get(&ref_links[2].reference_id()?)
            .unwrap()
            .contents()
            .text_contents(),
        "Named reference."
    );
    assert_eq!(ref_links[3].group()?, Some("group".to_string()));
    assert_eq!(
        ref_links[3].reference_id()?,
        "mw-reference-text-cite_note-bar-3"
    );
    assert_eq!(ref_links[3].id(), "cite_ref-bar_3-0");
    assert_eq!(
        all_refs
            .get(&ref_links[3].reference_id()?)
            .unwrap()
            .contents()
            .text_contents(),
        "reference!"
    );

    ref_links[0].set_group("new-group".to_string())?;
    let wikitext = client.transform_to_wikitext(&code).await?;
    dbg!(&wikitext);
    assert!(&wikitext
        .contains("<ref group=\"new-group\">This is a [[reference]].</ref>"));

    Ok(())
}

/// Verify you can edit a template inside a <ref> node
#[tokio::test]
async fn test_mutablity() -> Result<()> {
    let client = test_client::testwp_client();
    let code = client.get("Mwbot-rs/Cite").await?.into_mutable();
    let refs_ = code.filter_references();
    let temps = refs_[0].filter_templates()?;
    dbg!(&refs_[0]);
    temps[0].set_param("2", "a second value")?;

    let wikitext = client.transform_to_wikitext(&code).await?;
    dbg!(&wikitext);
    assert!(wikitext.contains("{{1x|reference!|a second value}}"));
    Ok(())
}

#[tokio::test]
async fn test_reference_lists() -> Result<()> {
    let client = test_client::testwp_client();
    let code = client.get("Mwbot-rs/Cite").await?.into_mutable();

    let lists = code.filter_reference_lists();
    assert_eq!(
        lists.len(),
        code.descendants()
            .filter_map(|node| node.as_reference_list())
            .count()
    );

    dbg!(&lists);
    assert_eq!(lists.len(), 2);

    assert_eq!(lists[0].group()?, Some("group".to_string()));
    assert!(lists[1].is_auto_generated()?);
    Ok(())
}