exile 0.0.9

DOM-Style XML 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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use crate::parser::error::Result;
use crate::parser::Iter;
use crate::Pi;

/// The iter should be pointing to the opening `<` of a processing instruction.
pub(crate) fn parse_pi_logic(iter: &mut Iter<'_>) -> Result<(String, String)> {
    expect!(iter, '<')?;
    iter.advance_or_die()?;
    expect!(iter, '?')?;
    iter.advance_or_die()?;

    // handle the special case <??>
    if iter.is('?') {
        iter.advance_or_die()?;
        expect!(iter, '>')?;
        iter.advance();
        return Ok(("".into(), "".into()));
    }

    let target = parse_pi_target(iter)?;
    let mut data = String::new();
    loop {
        if iter.is('?') && iter.peek_is('>') {
            iter.advance_or_die()?;
            iter.advance();
            break;
        }
        data.push(iter.st.c);
        iter.advance_or_die()?;
    }
    Ok((target, data))
}

/// Must be a valid name terminated by whitespace.
fn parse_pi_target(iter: &mut Iter<'_>) -> Result<String> {
    if !iter.is_name_start_char() {
        return parse_err!(iter, "expected name start char, found '{}'", iter.st.c);
    }
    let mut name = String::new();
    name.push(iter.st.c);
    iter.advance_or_die()?;
    loop {
        if iter.is_whitespace() {
            iter.advance_or_die()?;
            break;
        } else if iter.is('?') {
            // e.g. <?target??
            break;
        } else if !iter.is_name_char() {
            return parse_err!(iter, "expected name char, found '{}'", iter.st.c);
        } else {
            name.push(iter.st.c);
        }
        iter.advance_or_die()?;
    }
    Ok(name)
}

/// The iter should be pointing to the opening `<` of a processing instruction.
pub(crate) fn parse_pi(iter: &mut Iter<'_>) -> Result<Pi> {
    let (target, data) = parse_pi_logic(iter)?;
    Ok(Pi::new_unchecked(target, data))
}

////////////////////////////////////////////////////////////////////////////////////////////////////

#[test]
fn parse_pi_easy() {
    let pi_str = "<?target data?>";
    let mut iter = Iter::new(pi_str).unwrap();
    let pi = parse_pi(&mut iter).unwrap();
    assert_eq!("target", pi.target());
    assert_eq!("data", pi.data());
    assert!(!iter.advance());
}

#[test]
fn parse_pi_peasy() {
    let pi_str = "<?target data?>X";
    let mut iter = Iter::new(pi_str).unwrap();
    let pi = parse_pi(&mut iter).unwrap();
    assert_eq!("target", pi.target());
    assert_eq!("data", pi.data());
    assert!(iter.is('X'));
}

#[test]
fn parse_pi_funky_1() {
    let pi_str = "<?pi some data ? >";
    let mut iter = Iter::new(pi_str).unwrap();
    let parse_result = parse_pi(&mut iter);
    assert!(parse_result.is_err());
}

#[test]
fn parse_pi_funky_2() {
    let pi_str = "<??>";
    let mut iter = Iter::new(pi_str).unwrap();
    let pi = parse_pi(&mut iter).unwrap();
    assert_eq!("", pi.target());
    assert!(pi.data().is_empty());
}

#[test]
fn parse_pi_funky_3() {
    // established as not-well-formed by jclark_not_wf_sa_003.xml
    let pi_str = "<? ?>";
    let mut iter = Iter::new(pi_str).unwrap();
    let parse_result = parse_pi(&mut iter);
    assert!(parse_result.is_err());
}

#[test]
fn parse_pi_funky_4() {
    let pi_str = "< ? ? >";
    let mut iter = Iter::new(pi_str).unwrap();
    let parse_result = parse_pi(&mut iter);
    assert!(parse_result.is_err());
}

#[test]
fn parse_pi_funky_5() {
    let pi_str = "<?bones?>";
    let mut iter = Iter::new(pi_str).unwrap();
    let pi = parse_pi(&mut iter).unwrap();
    assert_eq!("bones", pi.target());
    assert!(pi.data().is_empty());
}

#[test]
fn parse_pi_funky_6() {
    // this is from jclark_valid_sa_017.xml
    let pi_str = "<?pi some data ? > <??>";
    let mut iter = Iter::new(pi_str).unwrap();
    let pi = parse_pi(&mut iter).unwrap();
    assert_eq!("pi", pi.target());
    assert_eq!("some data ? > <?", pi.data());
}