svgparser 0.8.1

Featureful, pull-based, zero-allocation SVG 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

extern crate svgparser;

use svgparser::{
    xmlparser,
};
use svgparser::transform::{
    Tokenizer,
    Token,
};

use xmlparser::{
    FromSpan,
};

macro_rules! test {
    ($name:ident, $text:expr, $($value:expr),*) => (
        #[test]
        fn $name() {
            let mut ts = Tokenizer::from_str($text);
            $(
                assert_eq!(ts.next().unwrap().unwrap(), $value);
            )*

            assert_eq!(ts.next().is_none(), true);
        }
    )
}

test!(matrix_1, "matrix(1 0 0 1 10 20)",
    Token::Matrix { a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: 10.0, f: 20.0 }
);

test!(matrix_2, "matrix(1, 0, 0, 1, 10, 20)",
    Token::Matrix { a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: 10.0, f: 20.0 }
);

test!(matrix_3, " matrix ( 1, 0, 0, 1, 10, 20 )",
    Token::Matrix { a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: 10.0, f: 20.0 }
);

test!(translate_1, "translate(10 20)",
    Token::Translate { tx: 10.0, ty: 20.0 }
);

test!(translate_2, "translate(10)",
    Token::Translate { tx: 10.0, ty: 0.0 }
);

test!(scale_1, "scale(2 3)",
    Token::Scale { sx: 2.0, sy: 3.0 }
);

test!(scale_2, "scale(2)",
    Token::Scale { sx: 2.0, sy: 2.0 }
);

test!(rotate_1, "rotate(30)",
    Token::Rotate { angle: 30.0 }
);

test!(rotate_2, "rotate(30 10 20)",
    Token::Translate { tx: 10.0, ty: 20.0 },
    Token::Rotate { angle: 30.0 },
    Token::Translate { tx: -10.0, ty: -20.0 }
);

test!(skew_y_1, "skewX(30)",
    Token::SkewX { angle: 30.0 }
);

test!(skew_x_1, "skewY(30)",
    Token::SkewY { angle: 30.0 }
);

test!(ts_list_1, "translate(-10,-20) scale(2) rotate(45) translate(5,10)",
    Token::Translate { tx: -10.0, ty: -20.0 },
    Token::Scale { sx: 2.0, sy: 2.0 },
    Token::Rotate { angle: 45.0 },
    Token::Translate { tx: 5.0, ty: 10.0 }
);

test!(ts_list_2, "translate(10,20), scale(2) ,  rotate(45),",
    Token::Translate { tx: 10.0, ty: 20.0 },
    Token::Scale { sx: 2.0, sy: 2.0 },
    Token::Rotate { angle: 45.0 }
);

#[test]
fn error_1() {
    let mut ts = Tokenizer::from_str("text");
    assert_eq!(ts.next().unwrap().unwrap_err().to_string(),
               "unexpected end of stream");
}

#[test]
fn error_2() {
    let mut ts = Tokenizer::from_str("scale(2) text");
    let _ = ts.next().unwrap();
    assert_eq!(ts.next().unwrap().unwrap_err().to_string(),
               "unexpected end of stream");
}

#[test]
fn error_3() {
    let mut ts = Tokenizer::from_str(" ");
    assert_eq!(ts.next().is_none(), true);
}

#[test]
fn error_4() {
    let mut ts = Tokenizer::from_str("???G");
    assert_eq!(ts.next().unwrap().unwrap_err().to_string(),
               "invalid name token");
}