vectordraw 0.1.2

A library for vector drawing with multiple output types
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

use super::backend::*;
use std::io::{Error, Write};

pub struct SvgBackend<W> {
    pub out: W,
    pub float_precision: usize
}

impl <W: Write> SvgBackend<W> {
    pub fn new(mut out: W) -> Result<SvgBackend<W>, Error> {
        write!(out, "<svg xmlns=\"http://www.w3.org/2000/svg\">\n")?;
        Ok(SvgBackend {
            out: out,
            float_precision: 2,
        })
    }
}

impl <W: Write> DrawBackend for SvgBackend<W> {
    type Error = Error;

    fn apply(&mut self, command: Command) -> Result<(), Error>{
        use super::backend::Command::*;

        match command {
            StartShape(options) => write!(&mut self.out, r#"    <path d=""#),
            MoveTo { x , y } => write!(&mut self.out, "M{:.p$},{:.p$} ", x, y, p=self.float_precision),
            LineTo { x, y } => write!(&mut self.out, "L{:.p$},{:.p$} ", x, y, p=self.float_precision),
            CubicCurveTo { cx1, cy1, cx2, cy2, x, y, } => unimplemented!(),
            QuadraticCurveTo { cx, cy, x, y, } => unimplemented!(),
            ArcTo { rx, ry, rotation, large_arc, sweep, x, y, } => unimplemented!(),
            CloseShape => writeln!(&mut self.out, r#"z"/>"#),
            EndShape => writeln!(&mut self.out, r#""/>"#),
        }
    }
    fn close(mut self) -> Result<(), Error> {
        write!(&mut self.out, "</svg>")
    }
}

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

    fn run_in_canvas<F>(f: F) -> String
    where F: FnOnce(&mut Canvas<SvgBackend<&mut Vec<u8>>>) -> Result<(), std::io::Error> {
        let mut buffer: Vec<u8> = Vec::new();
        {
            let mut canvas = Canvas::new(SvgBackend::new(&mut buffer).unwrap());
            f(&mut canvas).unwrap();
            canvas.close().unwrap();
        }
        return String::from_utf8(buffer).unwrap();
    }

    #[test]
    fn empty() {
        assert_eq!(run_in_canvas(|canvas| {
            Ok(())
        }).trim(), r#"
<svg xmlns="http://www.w3.org/2000/svg">
</svg>
        "#.trim())
    }

    #[test]
    fn empty_polygon() {
        assert_eq!(run_in_canvas(|canvas| {
            canvas.draw_closed_polygon(&[], DrawOptions::default())?;
            Ok(())
        }).trim(), r#"
<svg xmlns="http://www.w3.org/2000/svg">
</svg>
        "#.trim())
    }

    #[test]
    fn triangle_polygon() {
        assert_eq!(run_in_canvas(|canvas| {
            canvas.draw_closed_polygon(&[(0.0, 0.0), (0.0, 50.0), (50.0, 0.0)], DrawOptions::default())?;
            Ok(())
        }).trim(), r#"
<svg xmlns="http://www.w3.org/2000/svg">
    <path d="M0,0 L0,50 L50,0 z"/>
</svg>
        "#.trim())
    }

    #[test]
    fn triangle_polygon_reversed() {
        assert_eq!(run_in_canvas(|canvas| {
            canvas.draw_closed_polygon(&[(50.0, 0.0), (0.0, 50.0), (0.0, 0.0)], DrawOptions::default())?;
            Ok(())
        }).trim(), r#"
<svg xmlns="http://www.w3.org/2000/svg">
    <path d="M0,0 L0,50 L50,0 z"/>
</svg>
        "#.trim())
    }

    #[test]
    fn triangle_polygon_reversed_with_holes() {
        assert_eq!(run_in_canvas(|canvas| {
            canvas.draw_holy_polygon(
                vec![&[(50.0, 0.0), (0.0, 50.0), (0.0, 0.0)] as &[_]],
                vec![&[(30.0, 10.0), (10.0, 30.0), (10.0, 10.0)] as &[_]],
                DrawOptions::default()
            )
        }).trim(), r#"
<svg xmlns="http://www.w3.org/2000/svg">
    <path d="M50,0 L0,0 L0,50 L50,0 M30,10 L10,30 L10,10 L30,10 "/>
</svg>
        "#.trim())
    }
}