dxpdf 0.3.1

A fast DOCX-to-PDF converter powered by Skia
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

use serde::{Deserialize, Deserializer};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct IntegerMeasure {
    value: i64,
    negative: bool,
}

impl IntegerMeasure {
    pub(crate) fn value(self) -> i64 {
        self.value
    }

    pub(crate) fn is_negative(&self) -> bool {
        self.negative
    }
}

impl<'de> Deserialize<'de> for IntegerMeasure {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let raw = String::deserialize(deserializer)?;
        parse_integer_measure(&raw).map_err(serde::de::Error::custom)
    }
}

fn parse_integer_measure(raw: &str) -> Result<IntegerMeasure, &'static str> {
    if let Ok(value) = raw.parse::<i64>() {
        return Ok(IntegerMeasure {
            value,
            negative: raw.starts_with('-'),
        });
    }

    let (negative, unsigned) = match raw.strip_prefix('-') {
        Some(rest) => (true, rest),
        None => (false, raw.strip_prefix('+').unwrap_or(raw)),
    };
    let (whole, fraction) = unsigned
        .split_once('.')
        .ok_or("expected an integer or decimal measurement")?;
    if whole.is_empty()
        || fraction.is_empty()
        || !whole.bytes().all(|b| b.is_ascii_digit())
        || !fraction.bytes().all(|b| b.is_ascii_digit())
    {
        return Err("invalid decimal measurement");
    }

    let magnitude = whole
        .parse::<i128>()
        .map_err(|_| "measurement is outside the supported range")?;
    let rounded_magnitude = magnitude
        .checked_add(i128::from(fraction.as_bytes()[0] >= b'5'))
        .ok_or("measurement is outside the supported range")?;
    let signed = if negative {
        -rounded_magnitude
    } else {
        rounded_magnitude
    };
    let value = i64::try_from(signed).map_err(|_| "measurement is outside the supported range")?;
    Ok(IntegerMeasure { value, negative })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[derive(Deserialize)]
    struct Value {
        #[serde(rename = "@val")]
        val: IntegerMeasure,
    }

    fn parse(raw: &str) -> Result<i64, quick_xml::DeError> {
        quick_xml::de::from_str::<Value>(&format!(r#"<x val="{raw}"/>"#))
            .map(|value| value.val.value())
    }

    #[test]
    fn accepts_integer_and_decimal_measurements() {
        assert_eq!(parse("0").unwrap(), 0);
        assert_eq!(parse("-120").unwrap(), -120);
        assert_eq!(parse("100.0").unwrap(), 100);
        assert_eq!(parse("252.00000000000003").unwrap(), 252);
        assert_eq!(parse("283.46456692913375").unwrap(), 283);
    }

    #[test]
    fn rounds_half_away_from_zero() {
        assert_eq!(parse("1.5").unwrap(), 2);
        assert_eq!(parse("-1.5").unwrap(), -2);
        assert_eq!(parse("1.499").unwrap(), 1);
        assert_eq!(parse("-1.499").unwrap(), -1);
    }

    #[test]
    fn rejects_non_decimal_and_out_of_range_values() {
        for raw in [
            "",
            ".5",
            "1.",
            "1e2",
            "NaN",
            "inf",
            "abc",
            "9223372036854775808",
            "-9223372036854775809",
        ] {
            assert!(parse(raw).is_err(), "{raw:?} must be rejected");
        }
    }
}