nom-xml 0.1.1-pre-alpha

A Rust Crate for parsing XML.
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

// decode.rs

use std::borrow::Cow;

use nom::{
    branch::alt,
    bytes::complete::{tag, take_until, take_while1},
    combinator::opt,
    sequence::delimited,
    IResult,
};

pub fn decode_entity(input: &str) -> IResult<&str, Cow<str>> {
    if input.is_empty() {
        return Ok((input, Cow::Borrowed(input)));
    }
    let (input, digit_code) = opt(delimited(
        tag("&#"),
        take_while1(|c: char| c.is_numeric()),
        tag(";"),
    ))(input)?;

    let (input, hex_code) = opt(delimited(
        alt((tag("&#x"), tag("&#X"))),
        take_while1(|c: char| c.is_numeric()),
        tag(";"),
    ))(input)?;

    if let Some(code) = digit_code {
        decode_digit(input, code)
    } else if let Some(code) = hex_code {
        decode_hex(input, code)
    } else {
        let (input, entity) = opt(delimited(tag("&"), take_until(";"), tag(";")))(input)?;

        if let Some(entity) = entity {
            let decoded_entity = match entity {
                "amp" => Cow::Borrowed("&"),
                "lt" => Cow::Borrowed("<"),
                "gt" => Cow::Borrowed(">"),
                "quot" => Cow::Borrowed("\""),
                "apos" => Cow::Borrowed("'"),
                _ => Cow::Borrowed(input),
            };
            if input == decoded_entity {
                Ok((input, Cow::Borrowed(input)))
            } else {
                Ok((input, decoded_entity))
            }
        } else {
            Ok((input, Cow::Borrowed(input)))
        }
    }
}

pub fn decode_hex<'a>(input: &'a str, code: &'a str) -> IResult<&'a str, Cow<'a, str>> {
    let decoded_entity = match u32::from_str_radix(code, 16) {
        Ok(n) => match char::from_u32(n) {
            Some(c) => Cow::Owned(c.to_string()),
            None => Cow::Owned(format!("Invalid Unicode scalar value: {}", n)),
        },
        Err(_) => Cow::Owned(format!("Invalid hexadecimal number: {}", code)),
    };
    if input == decoded_entity {
        Ok((input, Cow::Borrowed(input)))
    } else {
        Ok((input, decoded_entity))
    }
}

pub fn decode_digit<'a>(input: &'a str, code: &'a str) -> IResult<&'a str, Cow<'a, str>> {
    let decoded_entity = match code.parse::<u32>() {
        Ok(n) => match char::from_u32(n) {
            Some(c) => Cow::Owned(c.to_string()),
            None => Cow::Owned(format!("Invalid Unicode scalar value: {}", n)),
        },
        Err(_) => Cow::Owned(format!("Invalid decimal number: {}", code)),
    };
    if input == decoded_entity {
        Ok((input, Cow::Borrowed(input)))
    } else {
        Ok((input, decoded_entity))
    }
}

pub fn decode_entities(input: &str) -> IResult<&str, Cow<str>> {
    let mut output = String::new();
    let mut input = input;
    loop {
        if input.is_empty() {
            break;
        }
        let (tail, decoded_entity) = decode_entity(input)?;
        if decoded_entity == Cow::Borrowed(input) {
            output.push_str(input);
            input = "";
        } else if decoded_entity.is_empty() || tail == input {
            break;
        } else {
            output.push_str(&decoded_entity);
            input = tail;
        }
    }
    Ok((input, Cow::Owned(output)))
}