svgtidy 0.1.3

High-performance SVG optimizer written in Rust
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
143
144
145
146
147
148
149
150

use crate::plugins::Plugin;
use crate::tree::{Document, Element, Node};

pub struct CleanupNumericValues {
    pub float_precision: usize,
    pub remove_px: bool,
    pub leading_zero: bool,
}

impl Default for CleanupNumericValues {
    fn default() -> Self {
        Self {
            float_precision: 3,
            remove_px: true,
            leading_zero: true,
        }
    }
}

impl Plugin for CleanupNumericValues {
    fn apply(&self, doc: &mut Document) {
        cleanup_numeric_in_nodes(&mut doc.root, self);
    }
}

fn cleanup_numeric_in_nodes(nodes: &mut Vec<Node>, opts: &CleanupNumericValues) {
    for node in nodes {
        if let Node::Element(elem) = node {
            cleanup_element_numeric(elem, opts);
            cleanup_numeric_in_nodes(&mut elem.children, opts);
        }
    }
}

fn cleanup_element_numeric(elem: &mut Element, opts: &CleanupNumericValues) {
    // List of attributes to check
    let numeric_attrs = [
        "x",
        "y",
        "width",
        "height",
        "r",
        "cx",
        "cy",
        "rx",
        "ry",
        "opacity",
        "fill-opacity",
        "stroke-opacity",
        "stroke-width",
        "font-size",
        "offset",
    ];

    for attr in numeric_attrs {
        if let Some(val) = elem.attributes.get_mut(attr) {
            let new_val = cleanup_number(val, opts);
            *val = new_val;
        }
    }
}

fn cleanup_number(val: &str, opts: &CleanupNumericValues) -> String {
    // 1. Remove px
    let mut clean_val = val.trim();
    if opts.remove_px && clean_val.ends_with("px") {
        clean_val = &clean_val[..clean_val.len() - 2];
    }

    // 2. Parse number
    if let Ok(num) = clean_val.parse::<f64>() {
        // 3. Round
        // Format with precision
        let p = opts.float_precision;
        let factor = 10u32.pow(p as u32) as f64;
        let rounded = (num * factor).round() / factor;

        let s = rounded.to_string();

        // 4. Remove leading zero: 0.5 -> .5, -0.5 -> -.5
        if opts.leading_zero {
            if s.starts_with("0.") {
                return s[1..].to_string();
            } else if s.starts_with("-0.") {
                return format!("-{}", &s[2..]);
            }
        }
        return s;
    }

    // Fallback if parse fails (e.g. lists, percentages if parser failed)
    val.to_string()
}

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

    #[test]
    fn test_cleanup_px() {
        let input = "<svg width=\"100px\" height=\"50.5px\"></svg>";
        let expected = "<svg width=\"100\" height=\"50.5\"/>";

        let mut doc = parser::parse(input).unwrap();
        let plugin = CleanupNumericValues::default();
        plugin.apply(&mut doc);

        assert_eq!(printer::print(&doc), expected);
    }

    #[test]
    fn test_round() {
        // default precision 3
        let input = "<svg opacity=\"0.123456\"></svg>";
        let expected = "<svg opacity=\".123\"/>";

        let mut doc = parser::parse(input).unwrap();
        let plugin = CleanupNumericValues::default();
        plugin.apply(&mut doc);

        assert_eq!(printer::print(&doc), expected);
    }

    #[test]
    fn test_leading_zero() {
        let input = "<svg opacity=\"0.5\"></svg>";
        let expected = "<svg opacity=\".5\"/>"; // default leading_zero=true

        let mut doc = parser::parse(input).unwrap();
        let plugin = CleanupNumericValues::default();
        plugin.apply(&mut doc);

        assert_eq!(printer::print(&doc), expected);
    }

    #[test]
    fn test_ignore_non_numeric() {
        let input = "<svg width=\"auto\"></svg>";
        // parse fails, keep original
        let expected = "<svg width=\"auto\"/>";

        let mut doc = parser::parse(input).unwrap();
        let plugin = CleanupNumericValues::default();
        plugin.apply(&mut doc);

        assert_eq!(printer::print(&doc), expected);
    }
}